// $antlr-format alignTrailingComments true, columnLimit 150, maxEmptyLinesToKeep 1, reflowComments false, useTab false
// $antlr-format allowShortRulesOnASingleLine true, allowShortBlocksOnASingleLine true, minEmptyLines 0, alignSemicolons ownLine
// $antlr-format alignColons trailing, singleLineOverrulesHangingColon true, alignLexerCommands true, alignLabels true, alignTrailers true

lexer grammar nasm_x86_64_Lexer;

options {
    caseInsensitive = true;
}

DB     : 'db';
DW     : 'dw';
DD     : 'dd';
DQ     : 'dq';
DT     : 'dt';
DO     : 'do';
DY     : 'dy';
DZ     : 'dz';
RESB   : 'resb';
RESW   : 'resw';
RESD   : 'resd';
RESQ   : 'resq';
REST   : 'rest';
RESO   : 'reso';
RESY   : 'resy';
RESZ   : 'resz';
INCBIN : 'incbin';

BYTE  : 'byte';
WORD  : 'word';
DWORD : 'dword';
QWORD : 'qword';
TWORD : 'tword';
OWORD : 'oword';
YWORD : 'yword';
ZWORD : 'zword';

DUP: 'dup';

COMMA                    : ',';
QUESTION                 : '?';
LEFT_PARENTHESIS         : '(';
RIGHT_PARENTHESIS        : ')';
LEFT_BRACKET             : '[';
RIGHT_BRACKET            : ']';
COLON                    : ':';
BOOLEAN_OR               : '||';
BOOLEAN_XOR              : '^^';
BOOLEAN_AND              : '&&';
EQUAL_1                  : '=';
EQUAL_2                  : '==';
NOT_EQUAL_1              : '!=';
NOT_EQUAL_2              : '<>';
LESS_THAN                : '<';
LESS_THAN_EQUAL          : '<=';
GREATER_THAN             : '>';
GREATER_THAN_EQUAL       : '>=';
SIGNED_COMPARISON        : '<=>';
BITWISE_OR               : '|';
BITWISE_XOR              : '^';
BITWISE_AND              : '&';
LEFT_SHIFT               : '<<';
RIGHT_SHIFT              : '>>';
LEFT_SHIFT_COMPLETENESS  : '<<<';
RIGHT_SHIFT_COMPLETENESS : '>>>';
PLUS                     : '+';
MINUS                    : '-';
MULTIPLICATION           : '*';
UNSIGNED_DIVISION        : '/';
SIGNED_DIVISION          : '//';
PERCENT                  : '%'; //Also is the signed module operator
SIGNED_MODULE            : '%%';
BITWISE_NOT              : '~';
BOOLEAN_NOT              : '!';
DOLLAR                   : '$';
DOUBLE_DOLLAR            : '$$';

AAA        : 'aaa';
AAD        : 'aad';
AAM        : 'aam';
AAS        : 'aas';
ADC        : 'adc';
ADD        : 'add';
AND        : 'and';
ARPL       : 'arpl';
BB0_RESET  : 'bb0_reset';
BB1_RESET  : 'bb1_reset';
BOUND      : 'bound';
BSF        : 'bsf';
BSR        : 'bsr';
BSWAP      : 'bswap';
BT         : 'bt';
BTC        : 'btc';
BTR        : 'btr';
BTS        : 'bts';
CALL       : 'call';
CBW        : 'cbw';
CDQ        : 'cdq';
CDQE       : 'cdqe';
CLC        : 'clc';
CLD        : 'cld';
CLI        : 'cli';
CLTS       : 'clts';
CMC        : 'cmc';
CMOVA      : 'cmova';
CMOVAE     : 'cmovae';
CMOVB      : 'cmovb';
CMOVBE     : 'cmovbe';
CMOVC      : 'cmovc';
CMOVE      : 'cmove';
CMOVGE     : 'cmovge';
CMOVL      : 'cmovl';
CMOVLE     : 'cmovle';
CMOVNA     : 'cmovna';
CMOVNAE    : 'cmovnae';
CMOVNB     : 'cmovnb';
CMOVNBE    : 'cmovnbe';
CMOVNC     : 'cmovnc';
CMOVNE     : 'cmovne';
CMOVNG     : 'cmovng';
CMOVNGE    : 'cmovnge';
CMOVNL     : 'cmovnl';
CMOVNO     : 'cmovno';
CMOVNP     : 'cmovnp';
CMOVNS     : 'cmovns';
CMOVNZ     : 'cmovnz';
CMOVO      : 'cmovo';
CMOVP      : 'cmovp';
CMOVPE     : 'cmovpe';
CMOVPO     : 'cmovpo';
CMOVS      : 'cmovs';
CMOVZ      : 'cmovz';
CMP        : 'cmp';
CMPSB      : 'cmpsb';
CMPSD      : 'cmpsd';
CMPSQ      : 'cmpsq';
CMPSW      : 'cmpsw';
CMPXCHG    : 'cmpxchg';
CMPXCHG16B : 'cmpxchg16b';
CMPXCHG486 : 'cmpxchg486';
CMPXCHG8B  : 'cmpxchg8b';
CPU_READ   : 'cpu_read';
CPU_WRITE  : 'cpu_write';
CPUID      : 'cpuid';
CQO        : 'cqo';
CWD        : 'cwd';
CWDE       : 'cwde';
DAA        : 'daa';
DAS        : 'das';
DEC        : 'dec';
DIV        : 'div';
DMINT      : 'dmint';
EMMS       : 'emms';
ENTER      : 'enter';
EQU        : 'equ';
F2XM1      : 'f2xm1';
FABS       : 'fabs';
FADD       : 'fadd';
FADDP      : 'faddp';
FBLD       : 'fbld';
FBSTP      : 'fbstp';
FCHS       : 'fchs';
FCLEX      : 'fclex';
FCMOVB     : 'fcmovb';
FCMOVBE    : 'fcmovbe';
FCMOVE     : 'fcmove';
FCMOVNB    : 'fcmovnb';
FCMOVNBE   : 'fcmovnbe';
FCMOVNE    : 'fcmovne';
FCMOVNU    : 'fcmovnu';
FCMOVU     : 'fcmovu';
FCOM       : 'fcom';
FCOMI      : 'fcomi';
FCOMIP     : 'fcomip';
FCOMP      : 'fcomp';
FCOMPP     : 'fcompp';
FCOS       : 'fcos';
FDECSTP    : 'fdecstp';
FDISI      : 'fdisi';
FDIV       : 'fdiv';
FDIVP      : 'fdivp';
FDIVR      : 'fdivr';
FDIVRP     : 'fdivrp';
FEMMS      : 'femms';
FENI       : 'feni';
FFREE      : 'ffree';
FFREEP     : 'ffreep';
FIADD      : 'fiadd';
FICOM      : 'ficom';
FICOMP     : 'ficomp';
FIDIV      : 'fidiv';
FIDIVR     : 'fidivr';
FILD       : 'fild';
FIMUL      : 'fimul';
FINCSTP    : 'fincstp';
FINIT      : 'finit';
FIST       : 'fist';
FISTP      : 'fistp';
FISTTP     : 'fisttp';
FISUB      : 'fisub';
FISUBR     : 'fisubr';
FLD        : 'fld';
FLD1       : 'fld1';
FLDCW      : 'fldcw';
FLDENV     : 'fldenv';
FLDL2E     : 'fldl2e';
FLDL2T     : 'fldl2t';
FLDLG2     : 'fldlg2';
FLDLN2     : 'fldln2';
FLDPI      : 'fldpi';
FLDZ       : 'fldz';
FMUL       : 'fmul';
FMULP      : 'fmulp';
FNCLEX     : 'fnclex';
FNDISI     : 'fndisi';
FNENI      : 'fneni';
FNINIT     : 'fninit';
FNOP       : 'fnop';
FNSAVE     : 'fnsave';
FNSTCW     : 'fnstcw';
FNSTENV    : 'fnstenv';
FNSTSW     : 'fnstsw';
FPATAN     : 'fpatan';
FPREM      : 'fprem';
FPREM1     : 'fprem1';
FPTAN      : 'fptan';
FRNDINT    : 'frndint';
FRSTOR     : 'frstor';
FSAVE      : 'fsave';
FSCALE     : 'fscale';
FSETPM     : 'fsetpm';
FSIN       : 'fsin';
FSINCOS    : 'fsincos';
FSQRT      : 'fsqrt';
FST        : 'fst';
FSTCW      : 'fstcw';
FSTENV     : 'fstenv';
FSTP       : 'fstp';
FSTSW      : 'fstsw';
FSUB       : 'fsub';
FSUBP      : 'fsubp';
FSUBR      : 'fsubr';
FSUBRP     : 'fsubrp';
FTST       : 'ftst';
FUCOM      : 'fucom';
FUCOMI     : 'fucomi';
FUCOMIP    : 'fucomip';
FUCOMP     : 'fucomp';
FUCOMPP    : 'fucompp';
FWAIT      : 'fwait';
FXAM       : 'fxam';
FXCH       : 'fxch';
FXTRACT    : 'fxtract';
FYL2X      : 'fyl2x';
FYL2XP1    : 'fyl2xp1';
HLT        : 'hlt';
IBTS       : 'ibts';
ICEBP      : 'icebp';
IDIV       : 'idiv';
IMUL       : 'imul';
IN         : 'in';
INC        : 'inc';
INSB       : 'insb';
INSD       : 'insd';
INSW       : 'insw';
INT        : 'int';
INT01      : 'int01';
INT03      : 'int03';
INT1       : 'int1';
INT3       : 'int3';
INTO       : 'into';
INVD       : 'invd';
INVLPG     : 'invlpg';
INVLPGA    : 'invlpga';
INVPCID    : 'invpcid';
IRET       : 'iret';
IRETD      : 'iretd';
IRETQ      : 'iretq';
IRETW      : 'iretw';
JA         : 'ja';
JAE        : 'jae';
JB         : 'jb';
JBE        : 'jbe';
JC         : 'jc';
JCXZ       : 'jcxz';
JE         : 'je';
JECXZ      : 'jecxz';
JG         : 'jg';
JGE        : 'jge';
JL         : 'jl';
JLE        : 'jle';
JMP        : 'jmp';
JMPE       : 'jmpe';
JNA        : 'jna';
JNAE       : 'jnae';
JNB        : 'jnb';
JNBE       : 'jnbe';
JNC        : 'jnc';
JNE        : 'jne';
JNG        : 'jng';
JNGE       : 'jnge';
JNL        : 'jnl';
JNLE       : 'jnle';
JNO        : 'jno';
JNP        : 'jnp';
JNS        : 'jns';
JNZ        : 'jnz';
JO         : 'jo';
JP         : 'jp';
JPE        : 'jpe';
JPO        : 'jpo';
JRCXZ      : 'jrcxz';
JS         : 'js';
JZ         : 'jz';
LAHF       : 'lahf';
LAR        : 'lar';
LDS        : 'lds';
LEA        : 'lea';
LEAVE      : 'leave';
LES        : 'les';
LFENCE     : 'lfence';
LFS        : 'lfs';
LGDT       : 'lgdt';
LGS        : 'lgs';
LIDT       : 'lidt';
LLDT       : 'lldt';
LMSW       : 'lmsw';
LOADALL    : 'loadall';
LOADALL286 : 'loadall286';
LODSB      : 'lodsb';
LODSD      : 'lodsd';
LODSQ      : 'lodsq';
LODSW      : 'lodsw';
LOOP       : 'loop';
LOOPE      : 'loope';
LOOPNE     : 'loopne';
LOOPNZ     : 'loopnz';
LOOPZ      : 'loopz';
LSL        : 'lsl';
LSS        : 'lss';
LTR        : 'ltr';
MFENCE     : 'mfence';
MONITOR    : 'monitor';
MONITORX   : 'monitorx';
MOV        : 'mov';
MOVD       : 'movd';
MOVQ       : 'movq';
MOVSB      : 'movsb';
MOVSD      : 'movsd';
MOVSQ      : 'movsq';
MOVSW      : 'movsw';
MOVSX      : 'movsx';
MOVSXD     : 'movsxd';
MOVZX      : 'movzx';
MUL        : 'mul';
MWAIT      : 'mwait';
MWAITX     : 'mwaitx';
NEG        : 'neg';
NOP        : 'nop';
NOT        : 'not';
OR         : 'or';
OUT        : 'out';
OUTSB      : 'outsb';
OUTSD      : 'outsd';
OUTSW      : 'outsw';
PACKSSDW   : 'packssdw';
PACKSSWB   : 'packsswb';
PACKUSWB   : 'packuswb';
PADDB      : 'paddb';
PADDD      : 'paddd';
PADDSB     : 'paddsb';
PADDSIW    : 'paddsiw';
PADDSW     : 'paddsw';
PADDUSB    : 'paddusb';
PADDUSW    : 'paddusw';
PADDW      : 'paddw';
PAND       : 'pand';
PANDN      : 'pandn';
PAUSE      : 'pause';
PAVEB      : 'paveb';
PAVGUSB    : 'pavgusb';
PCMPEQB    : 'pcmpeqb';
PCMPEQD    : 'pcmpeqd';
PCMPEQW    : 'pcmpeqw';
PCMPGTB    : 'pcmpgtb';
PCMPGTD    : 'pcmpgtd';
PCMPGTW    : 'pcmpgtw';
PDISTIB    : 'pdistib';
PF2ID      : 'pf2id';
PFACC      : 'pfacc';
PFADD      : 'pfadd';
PFCMPEQ    : 'pfcmpeq';
PFCMPGE    : 'pfcmpge';
PFCMPGT    : 'pfcmpgt';
PFMAX      : 'pfmax';
PFMIN      : 'pfmin';
PFMUL      : 'pfmul';
PFRCP      : 'pfrcp';
PFRCPIT1   : 'pfrcpit1';
PFRCPIT2   : 'pfrcpit2';
PFRSQIT1   : 'pfrsqit1';
PFRSQRT    : 'pfrsqrt';
PFSUB      : 'pfsub';
PFSUBR     : 'pfsubr';
PI2FD      : 'pi2fd';
PMACHRIW   : 'pmachriw';
PMADDWD    : 'pmaddwd';
PMAGW      : 'pmagw';
PMULHRIW   : 'pmulhriw';
PMULHRWA   : 'pmulhrwa';
PMULHRWC   : 'pmulhrwc';
PMULHW     : 'pmulhw';
PMULLW     : 'pmullw';
PMVGEZB    : 'pmvgezb';
PMVLZB     : 'pmvlzb';
PMVNZB     : 'pmvnzb';
PMVZB      : 'pmvzb';
POP        : 'pop';
POPA       : 'popa';
POPAD      : 'popad';
POPAW      : 'popaw';
POPF       : 'popf';
POPFD      : 'popfd';
POPFQ      : 'popfq';
POPFW      : 'popfw';
POR        : 'por';
PREFETCH   : 'prefetch';
PREFETCHW  : 'prefetchw';
PSLLD      : 'pslld';
PSLLQ      : 'psllq';
PSLLW      : 'psllw';
PSRAD      : 'psrad';
PSRAW      : 'psraw';
PSRLD      : 'psrld';
PSRLQ      : 'psrlq';
PSRLW      : 'psrlw';
PSUBB      : 'psubb';
PSUBD      : 'psubd';
PSUBSB     : 'psubsb';
PSUBSIW    : 'psubsiw';
PSUBSW     : 'psubsw';
PSUBUSB    : 'psubusb';
PSUBUSW    : 'psubusw';
PSUBW      : 'psubw';
PUNPCKHBW  : 'punpckhbw';
PUNPCKHDQ  : 'punpckhdq';
PUNPCKHWD  : 'punpckhwd';
PUNPCKLBW  : 'punpcklbw';
PUNPCKLDQ  : 'punpckldq';
PUNPCKLWD  : 'punpcklwd';
PUSH       : 'push';
PUSHA      : 'pusha';
PUSHAD     : 'pushad';
PUSHAW     : 'pushaw';
PUSHF      : 'pushf';
PUSHFD     : 'pushfd';
PUSHFQ     : 'pushfq';
PUSHFW     : 'pushfw';
PXOR       : 'pxor';
RCL        : 'rcl';
RCR        : 'rcr';
RDM        : 'rdm';
RDMSR      : 'rdmsr';
RDPMC      : 'rdpmc';
RDSHR      : 'rdshr';
RDTSC      : 'rdtsc';
RDTSCP     : 'rdtscp';
RET        : 'ret';
RETD       : 'retd';
RETF       : 'retf';
RETFD      : 'retfd';
RETFQ      : 'retfq';
RETFW      : 'retfw';
RETN       : 'retn';
RETND      : 'retnd';
RETNQ      : 'retnq';
RETNW      : 'retnw';
RETQ       : 'retq';
RETW       : 'retw';
ROL        : 'rol';
ROR        : 'ror';
RSDC       : 'rsdc';
RSLDT      : 'rsldt';
RSM        : 'rsm';
RSTS       : 'rsts';
SAHF       : 'sahf';
SAL        : 'sal';
SALC       : 'salc';
SAR        : 'sar';
SBB        : 'sbb';
SCASB      : 'scasb';
SCASD      : 'scasd';
SCASQ      : 'scasq';
SCASW      : 'scasw';
SETA       : 'seta';
SETAE      : 'setae';
SETB       : 'setb';
SETBE      : 'setbe';
SETC       : 'setc';
SETE       : 'sete';
SETG       : 'setg';
SETGE      : 'setge';
SETL       : 'setl';
SETLE      : 'setle';
SETNA      : 'setna';
SETNAE     : 'setnae';
SETNB      : 'setnb';
SETNBE     : 'setnbe';
SETNC      : 'setnc';
SETNE      : 'setne';
SETNG      : 'setng';
SETNGE     : 'setnge';
SETNL      : 'setnl';
SETNLE     : 'setnle';
SETNO      : 'setno';
SETNP      : 'setnp';
SETNS      : 'setns';
SETNZ      : 'setnz';
SETO       : 'seto';
SETP       : 'setp';
SETPE      : 'setpe';
SETPO      : 'setpo';
SETS       : 'sets';
SETZ       : 'setz';
SFENCE     : 'sfence';
SGDT       : 'sgdt';
SHL        : 'shl';
SHLD       : 'shld';
SHR        : 'shr';
SHRD       : 'shrd';
SIDT       : 'sidt';
SKINIT     : 'skinit';
SLDT       : 'sldt';
SMI        : 'smi';
SMINT      : 'smint';
SMINTOLD   : 'smintold';
SMSW       : 'smsw';
STC        : 'stc';
STD        : 'std';
STI        : 'sti';
STOSB      : 'stosb';
STOSD      : 'stosd';
STOSQ      : 'stosq';
STOSW      : 'stosw';
STR        : 'str';
SUB        : 'sub';
SVDC       : 'svdc';
SVLDT      : 'svldt';
SVTS       : 'svts';
SWAPGS     : 'swapgs';
SYSCALL    : 'syscall';
SYSENTER   : 'sysenter';
SYSEXIT    : 'sysexit';
SYSRET     : 'sysret';
TEST       : 'test';
UD0        : 'ud0';
UD1        : 'ud1';
UD2        : 'ud2';
UD2A       : 'ud2a';
UD2B       : 'ud2b';
UMOV       : 'umov';
VERR       : 'verr';
VERW       : 'verw';
WBINVD     : 'wbinvd';
WRMSR      : 'wrmsr';
WRSHR      : 'wrshr';
XADD       : 'xadd';
XBTS       : 'xbts';
XCHG       : 'xchg';
XLAT       : 'xlat';
XLATB      : 'xlatb';
XOR        : 'xor';

AL    : 'al';
AH    : 'ah';
AX    : 'ax';
EAX   : 'eax';
RAX   : 'rax';
BL    : 'bl';
BH    : 'bh';
BX    : 'bx';
EBX   : 'ebx';
RBX   : 'rbx';
CL    : 'cl';
CH    : 'ch';
CX    : 'cx';
ECX   : 'ecx';
RCX   : 'rcx';
DL    : 'dl';
DH    : 'dh';
DX    : 'dx';
EDX   : 'edx';
RDX   : 'rdx';
SPL   : 'spl';
SP    : 'sp';
ESP   : 'esp';
RSP   : 'rsp';
BPL   : 'bpl';
BP    : 'bp';
EBP   : 'ebp';
RBP   : 'rbp';
SIL   : 'sil';
SI    : 'si';
ESI   : 'esi';
RSI   : 'rsi';
DIL   : 'dil';
DI    : 'di';
EDI   : 'edi';
RDI   : 'rdi';
R8B   : 'r8b';
R9B   : 'r9b';
R10B  : 'r10b';
R11B  : 'r11b';
R12B  : 'r12b';
R13B  : 'r13b';
R14B  : 'r14b';
R15B  : 'r15b';
R8W   : 'r8w';
R9W   : 'r9w';
R10W  : 'r10w';
R11W  : 'r11w';
R12W  : 'r12w';
R13W  : 'r13w';
R14W  : 'r14w';
R15W  : 'r15w';
R8D   : 'r8d';
R9D   : 'r9d';
R10D  : 'r10d';
R11D  : 'r11d';
R12D  : 'r12d';
R13D  : 'r13d';
R14D  : 'r14d';
R15D  : 'r15d';
R8    : 'r8';
R9    : 'r9';
R10   : 'r10';
R11   : 'r11';
R12   : 'r12';
R13   : 'r13';
R14   : 'r14';
R15   : 'r15';
IP    : 'ip';
EIP   : 'eip';
RIP   : 'rip';
ES    : 'es';
CS    : 'cs';
SS    : 'ss';
DS    : 'ds';
FS    : 'fs';
GS    : 'gs';
SEGR6 : 'segr6';
SEGR7 : 'segr7';
CR0   : 'cr0';
CR1   : 'cr1';
CR2   : 'cr2';
CR3   : 'cr3';
CR4   : 'cr4';
CR5   : 'cr5';
CR6   : 'cr6';
CR7   : 'cr7';
CR8   : 'cr8';
CR9   : 'cr9';
CR10  : 'cr10';
CR11  : 'cr11';
CR12  : 'cr12';
CR13  : 'cr13';
CR14  : 'cr14';
CR15  : 'cr15';
DR0   : 'dr0';
DR1   : 'dr1';
DR2   : 'dr2';
DR3   : 'dr3';
DR4   : 'dr4';
DR5   : 'dr5';
DR6   : 'dr6';
DR7   : 'dr7';
DR8   : 'dr8';
DR9   : 'dr9';
DR10  : 'dr10';
DR11  : 'dr11';
DR12  : 'dr12';
DR13  : 'dr13';
DR14  : 'dr14';
DR15  : 'dr15';
TR0   : 'tr0';
TR1   : 'tr1';
TR2   : 'tr2';
TR3   : 'tr3';
TR4   : 'tr4';
TR5   : 'tr5';
TR6   : 'tr6';
TR7   : 'tr7';
ST0   : 'st0';
ST1   : 'st1';
ST2   : 'st2';
ST3   : 'st3';
ST4   : 'st4';
ST5   : 'st5';
ST6   : 'st6';
ST7   : 'st7';
MM0   : 'mm0';
MM1   : 'mm1';
MM2   : 'mm2';
MM3   : 'mm3';
MM4   : 'mm4';
MM5   : 'mm5';
MM6   : 'mm6';
MM7   : 'mm7';
XMM0  : 'xmm0';
XMM1  : 'xmm1';
XMM2  : 'xmm2';
XMM3  : 'xmm3';
XMM4  : 'xmm4';
XMM5  : 'xmm5';
XMM6  : 'xmm6';
XMM7  : 'xmm7';
XMM8  : 'xmm8';
XMM9  : 'xmm9';
XMM10 : 'xmm10';
XMM11 : 'xmm11';
XMM12 : 'xmm12';
XMM13 : 'xmm13';
XMM14 : 'xmm14';
XMM15 : 'xmm15';
XMM16 : 'xmm16';
XMM17 : 'xmm17';
XMM18 : 'xmm18';
XMM19 : 'xmm19';
XMM20 : 'xmm20';
XMM21 : 'xmm21';
XMM22 : 'xmm22';
XMM23 : 'xmm23';
XMM24 : 'xmm24';
XMM25 : 'xmm25';
XMM26 : 'xmm26';
XMM27 : 'xmm27';
XMM28 : 'xmm28';
XMM29 : 'xmm29';
XMM30 : 'xmm30';
XMM31 : 'xmm31';
YMM0  : 'ymm0';
YMM1  : 'ymm1';
YMM2  : 'ymm2';
YMM3  : 'ymm3';
YMM4  : 'ymm4';
YMM5  : 'ymm5';
YMM6  : 'ymm6';
YMM7  : 'ymm7';
YMM8  : 'ymm8';
YMM9  : 'ymm9';
YMM10 : 'ymm10';
YMM11 : 'ymm11';
YMM12 : 'ymm12';
YMM13 : 'ymm13';
YMM14 : 'ymm14';
YMM15 : 'ymm15';
YMM16 : 'ymm16';
YMM17 : 'ymm17';
YMM18 : 'ymm18';
YMM19 : 'ymm19';
YMM20 : 'ymm20';
YMM21 : 'ymm21';
YMM22 : 'ymm22';
YMM23 : 'ymm23';
YMM24 : 'ymm24';
YMM25 : 'ymm25';
YMM26 : 'ymm26';
YMM27 : 'ymm27';
YMM28 : 'ymm28';
YMM29 : 'ymm29';
YMM30 : 'ymm30';
YMM31 : 'ymm31';
ZMM0  : 'zmm0';
ZMM1  : 'zmm1';
ZMM2  : 'zmm2';
ZMM3  : 'zmm3';
ZMM4  : 'zmm4';
ZMM5  : 'zmm5';
ZMM6  : 'zmm6';
ZMM7  : 'zmm7';
ZMM8  : 'zmm8';
ZMM9  : 'zmm9';
ZMM10 : 'zmm10';
ZMM11 : 'zmm11';
ZMM12 : 'zmm12';
ZMM13 : 'zmm13';
ZMM14 : 'zmm14';
ZMM15 : 'zmm15';
ZMM16 : 'zmm16';
ZMM17 : 'zmm17';
ZMM18 : 'zmm18';
ZMM19 : 'zmm19';
ZMM20 : 'zmm20';
ZMM21 : 'zmm21';
ZMM22 : 'zmm22';
ZMM23 : 'zmm23';
ZMM24 : 'zmm24';
ZMM25 : 'zmm25';
ZMM26 : 'zmm26';
ZMM27 : 'zmm27';
ZMM28 : 'zmm28';
ZMM29 : 'zmm29';
ZMM30 : 'zmm30';
ZMM31 : 'zmm31';
TMM0  : 'tmm0';
TMM1  : 'tmm1';
TMM2  : 'tmm2';
TMM3  : 'tmm3';
TMM4  : 'tmm4';
TMM5  : 'tmm5';
TMM6  : 'tmm6';
TMM7  : 'tmm7';
K0    : 'k0';
K1    : 'k1';
K2    : 'k2';
K3    : 'k3';
K4    : 'k4';
K5    : 'k5';
K6    : 'k6';
K7    : 'k7';
BND0  : 'bnd0';
BND1  : 'bnd1';
BND2  : 'bnd2';
BND3  : 'bnd3';

AADD              : 'aadd';
AAND              : 'aand';
ADCX              : 'adcx';
ADDPD             : 'addpd';
ADDPS             : 'addps';
ADDSD             : 'addsd';
ADDSS             : 'addss';
ADDSUBPD          : 'addsubpd';
ADDSUBPS          : 'addsubps';
ADOX              : 'adox';
AESDEC            : 'aesdec';
AESDECLAST        : 'aesdeclast';
AESENC            : 'aesenc';
AESENCLAST        : 'aesenclast';
AESIMC            : 'aesimc';
AESKEYGENASSIST   : 'aeskeygenassist';
ANDN              : 'andn';
ANDNPD            : 'andnpd';
ANDNPS            : 'andnps';
ANDPD             : 'andpd';
ANDPS             : 'andps';
AXOR              : 'axor';
BEXTR             : 'bextr';
BLCFILL           : 'blcfill';
BLCI              : 'blci';
BLCIC             : 'blcic';
BLCMSK            : 'blcmsk';
BLCS              : 'blcs';
BLENDPD           : 'blendpd';
BLENDPS           : 'blendps';
BLENDVPD          : 'blendvpd';
BLENDVPS          : 'blendvps';
BLSFILL           : 'blsfill';
BLSI              : 'blsi';
BLSIC             : 'blsic';
BLSMSK            : 'blsmsk';
BLSR              : 'blsr';
BNDCL             : 'bndcl';
BNDCN             : 'bndcn';
BNDCU             : 'bndcu';
BNDLDX            : 'bndldx';
BNDMK             : 'bndmk';
BNDMOV            : 'bndmov';
BNDSTX            : 'bndstx';
BZHI              : 'bzhi';
CLAC              : 'clac';
CLDEMOTE          : 'cldemote';
CLFLUSH           : 'clflush';
CLFLUSHOPT        : 'clflushopt';
CLGI              : 'clgi';
CLRSSBSY          : 'clrssbsy';
CLUI              : 'clui';
CLWB              : 'clwb';
CLZERO            : 'clzero';
CMPEQPD           : 'cmpeqpd';
CMPEQPS           : 'cmpeqps';
CMPEQSD           : 'cmpeqsd';
CMPEQSS           : 'cmpeqss';
CMPLEPD           : 'cmplepd';
CMPLEPS           : 'cmpleps';
CMPLESD           : 'cmplesd';
CMPLESS           : 'cmpless';
CMPLTPD           : 'cmpltpd';
CMPLTPS           : 'cmpltps';
CMPLTSD           : 'cmpltsd';
CMPLTSS           : 'cmpltss';
CMPNEQPD          : 'cmpneqpd';
CMPNEQPS          : 'cmpneqps';
CMPNEQSD          : 'cmpneqsd';
CMPNEQSS          : 'cmpneqss';
CMPNLEPD          : 'cmpnlepd';
CMPNLEPS          : 'cmpnleps';
CMPNLESD          : 'cmpnlesd';
CMPNLESS          : 'cmpnless';
CMPNLTPD          : 'cmpnltpd';
CMPNLTPS          : 'cmpnltps';
CMPNLTSD          : 'cmpnltsd';
CMPNLTSS          : 'cmpnltss';
CMPNPXADD         : 'cmpnpxadd';
CMPNSXADD         : 'cmpnsxadd';
CMPNZXADD         : 'cmpnzxadd';
CMPORDPD          : 'cmpordpd';
CMPORDPS          : 'cmpordps';
CMPORDSD          : 'cmpordsd';
CMPORDSS          : 'cmpordss';
CMPOXADD          : 'cmpoxadd';
CMPPD             : 'cmppd';
CMPPS             : 'cmpps';
CMPPXADD          : 'cmppxadd';
CMPSS             : 'cmpss';
CMPSXADD          : 'cmpsxadd';
CMPUNORDPD        : 'cmpunordpd';
CMPUNORDPS        : 'cmpunordps';
CMPUNORDSD        : 'cmpunordsd';
CMPUNORDSS        : 'cmpunordss';
CMPZXADD          : 'cmpzxadd';
COMISD            : 'comisd';
COMISS            : 'comiss';
CRC32             : 'crc32';
CVTDQ2PD          : 'cvtdq2pd';
CVTDQ2PS          : 'cvtdq2ps';
CVTPD2DQ          : 'cvtpd2dq';
CVTPD2PI          : 'cvtpd2pi';
CVTPD2PS          : 'cvtpd2ps';
CVTPI2PD          : 'cvtpi2pd';
CVTPI2PS          : 'cvtpi2ps';
CVTPS2DQ          : 'cvtps2dq';
CVTPS2PD          : 'cvtps2pd';
CVTPS2PI          : 'cvtps2pi';
CVTSD2SI          : 'cvtsd2si';
CVTSD2SS          : 'cvtsd2ss';
CVTSI2SD          : 'cvtsi2sd';
CVTSI2SS          : 'cvtsi2ss';
CVTSS2SD          : 'cvtss2sd';
CVTSS2SI          : 'cvtss2si';
CVTTPD2DQ         : 'cvttpd2dq';
CVTTPD2PI         : 'cvttpd2pi';
CVTTPS2DQ         : 'cvttps2dq';
CVTTPS2PI         : 'cvttps2pi';
CVTTSD2SI         : 'cvttsd2si';
CVTTSS2SI         : 'cvttss2si';
DIVPD             : 'divpd';
DIVPS             : 'divps';
DIVSD             : 'divsd';
DIVSS             : 'divss';
DPPD              : 'dppd';
DPPS              : 'dpps';
ENCLS             : 'encls';
ENCLU             : 'enclu';
ENCLV             : 'enclv';
ENDBR32           : 'endbr32';
ENDBR64           : 'endbr64';
ENQCMD            : 'enqcmd';
ENQCMDS           : 'enqcmds';
EXTRACTPS         : 'extractps';
EXTRQ             : 'extrq';
FXRSTOR           : 'fxrstor';
FXRSTOR64         : 'fxrstor64';
FXSAVE            : 'fxsave';
FXSAVE64          : 'fxsave64';
GETSEC            : 'getsec';
GF2P8AFFINEINVQB  : 'gf2p8affineinvqb';
GF2P8AFFINEQB     : 'gf2p8affineqb';
GF2P8MULB         : 'gf2p8mulb';
HADDPD            : 'haddpd';
HADDPS            : 'haddps';
HINT_NOP0         : 'hint_nop0';
HINT_NOP1         : 'hint_nop1';
HINT_NOP10        : 'hint_nop10';
HINT_NOP11        : 'hint_nop11';
HINT_NOP12        : 'hint_nop12';
HINT_NOP13        : 'hint_nop13';
HINT_NOP14        : 'hint_nop14';
HINT_NOP15        : 'hint_nop15';
HINT_NOP16        : 'hint_nop16';
HINT_NOP17        : 'hint_nop17';
HINT_NOP18        : 'hint_nop18';
HINT_NOP19        : 'hint_nop19';
HINT_NOP2         : 'hint_nop2';
HINT_NOP20        : 'hint_nop20';
HINT_NOP21        : 'hint_nop21';
HINT_NOP22        : 'hint_nop22';
HINT_NOP23        : 'hint_nop23';
HINT_NOP24        : 'hint_nop24';
HINT_NOP25        : 'hint_nop25';
HINT_NOP26        : 'hint_nop26';
HINT_NOP27        : 'hint_nop27';
HINT_NOP28        : 'hint_nop28';
HINT_NOP29        : 'hint_nop29';
HINT_NOP3         : 'hint_nop3';
HINT_NOP30        : 'hint_nop30';
HINT_NOP31        : 'hint_nop31';
HINT_NOP32        : 'hint_nop32';
HINT_NOP33        : 'hint_nop33';
HINT_NOP34        : 'hint_nop34';
HINT_NOP35        : 'hint_nop35';
HINT_NOP36        : 'hint_nop36';
HINT_NOP37        : 'hint_nop37';
HINT_NOP38        : 'hint_nop38';
HINT_NOP39        : 'hint_nop39';
HINT_NOP4         : 'hint_nop4';
HINT_NOP40        : 'hint_nop40';
HINT_NOP41        : 'hint_nop41';
HINT_NOP42        : 'hint_nop42';
HINT_NOP43        : 'hint_nop43';
HINT_NOP44        : 'hint_nop44';
HINT_NOP45        : 'hint_nop45';
HINT_NOP46        : 'hint_nop46';
HINT_NOP47        : 'hint_nop47';
HINT_NOP48        : 'hint_nop48';
HINT_NOP49        : 'hint_nop49';
HINT_NOP5         : 'hint_nop5';
HINT_NOP50        : 'hint_nop50';
HINT_NOP51        : 'hint_nop51';
HINT_NOP52        : 'hint_nop52';
HINT_NOP53        : 'hint_nop53';
HINT_NOP54        : 'hint_nop54';
HINT_NOP55        : 'hint_nop55';
HINT_NOP56        : 'hint_nop56';
HINT_NOP57        : 'hint_nop57';
HINT_NOP58        : 'hint_nop58';
HINT_NOP59        : 'hint_nop59';
HINT_NOP6         : 'hint_nop6';
HINT_NOP60        : 'hint_nop60';
HINT_NOP61        : 'hint_nop61';
HINT_NOP62        : 'hint_nop62';
HINT_NOP63        : 'hint_nop63';
HINT_NOP7         : 'hint_nop7';
HINT_NOP8         : 'hint_nop8';
HINT_NOP9         : 'hint_nop9';
HRESET            : 'hreset';
HSUBPD            : 'hsubpd';
HSUBPS            : 'hsubps';
INCSSPD           : 'incsspd';
INCSSPQ           : 'incsspq';
INSERTPS          : 'insertps';
INSERTQ           : 'insertq';
INVEPT            : 'invept';
INVVPID           : 'invvpid';
KADD              : 'kadd';
KADDB             : 'kaddb';
KADDD             : 'kaddd';
KADDQ             : 'kaddq';
KADDW             : 'kaddw';
KAND              : 'kand';
KANDB             : 'kandb';
KANDD             : 'kandd';
KANDN             : 'kandn';
KANDNB            : 'kandnb';
KANDND            : 'kandnd';
KANDNQ            : 'kandnq';
KANDNW            : 'kandnw';
KANDQ             : 'kandq';
KANDW             : 'kandw';
KMOV              : 'kmov';
KMOVB             : 'kmovb';
KMOVD             : 'kmovd';
KMOVQ             : 'kmovq';
KMOVW             : 'kmovw';
KNOT              : 'knot';
KNOTB             : 'knotb';
KNOTD             : 'knotd';
KNOTQ             : 'knotq';
KNOTW             : 'knotw';
KOR               : 'kor';
KORB              : 'korb';
KORD              : 'kord';
KORQ              : 'korq';
KORTEST           : 'kortest';
KORTESTB          : 'kortestb';
KORTESTD          : 'kortestd';
KORTESTQ          : 'kortestq';
KORTESTW          : 'kortestw';
KORW              : 'korw';
KSHIFTL           : 'kshiftl';
KSHIFTLB          : 'kshiftlb';
KSHIFTLD          : 'kshiftld';
KSHIFTLQ          : 'kshiftlq';
KSHIFTLW          : 'kshiftlw';
KSHIFTR           : 'kshiftr';
KSHIFTRB          : 'kshiftrb';
KSHIFTRD          : 'kshiftrd';
KSHIFTRQ          : 'kshiftrq';
KSHIFTRW          : 'kshiftrw';
KTEST             : 'ktest';
KTESTB            : 'ktestb';
KTESTD            : 'ktestd';
KTESTQ            : 'ktestq';
KTESTW            : 'ktestw';
KUNPCK            : 'kunpck';
KUNPCKBW          : 'kunpckbw';
KUNPCKDQ          : 'kunpckdq';
KUNPCKWD          : 'kunpckwd';
KXNOR             : 'kxnor';
KXNORB            : 'kxnorb';
KXNORD            : 'kxnord';
KXNORQ            : 'kxnorq';
KXNORW            : 'kxnorw';
KXOR              : 'kxor';
KXORB             : 'kxorb';
KXORD             : 'kxord';
KXORQ             : 'kxorq';
KXORW             : 'kxorw';
LDDQU             : 'lddqu';
LDMXCSR           : 'ldmxcsr';
LDTILECFG         : 'ldtilecfg';
LLWPCB            : 'llwpcb';
LWPINS            : 'lwpins';
LWPVAL            : 'lwpval';
LZCNT             : 'lzcnt';
MASKMOVDQU        : 'maskmovdqu';
MASKMOVQ          : 'maskmovq';
MAXPD             : 'maxpd';
MAXPS             : 'maxps';
MAXSD             : 'maxsd';
MAXSS             : 'maxss';
MINPD             : 'minpd';
MINPS             : 'minps';
MINSD             : 'minsd';
MINSS             : 'minss';
MONTMUL           : 'montmul';
MOVAPD            : 'movapd';
MOVAPS            : 'movaps';
MOVBE             : 'movbe';
MOVDDUP           : 'movddup';
MOVDIR64B         : 'movdir64b';
MOVDIRI           : 'movdiri';
MOVDQ2Q           : 'movdq2q';
MOVDQA            : 'movdqa';
MOVDQU            : 'movdqu';
MOVHLPS           : 'movhlps';
MOVHPD            : 'movhpd';
MOVHPS            : 'movhps';
MOVLHPS           : 'movlhps';
MOVLPD            : 'movlpd';
MOVLPS            : 'movlps';
MOVMSKPD          : 'movmskpd';
MOVMSKPS          : 'movmskps';
MOVNTDQ           : 'movntdq';
MOVNTDQA          : 'movntdqa';
MOVNTI            : 'movnti';
MOVNTPD           : 'movntpd';
MOVNTPS           : 'movntps';
MOVNTQ            : 'movntq';
MOVNTSD           : 'movntsd';
MOVNTSS           : 'movntss';
MOVQ2DQ           : 'movq2dq';
MOVSHDUP          : 'movshdup';
MOVSLDUP          : 'movsldup';
MOVSS             : 'movss';
MOVUPD            : 'movupd';
MOVUPS            : 'movups';
MPSADBW           : 'mpsadbw';
MULPD             : 'mulpd';
MULPS             : 'mulps';
MULSD             : 'mulsd';
MULSS             : 'mulss';
MULX              : 'mulx';
ORPD              : 'orpd';
ORPS              : 'orps';
PABSB             : 'pabsb';
PABSD             : 'pabsd';
PABSW             : 'pabsw';
PACKUSDW          : 'packusdw';
PADDQ             : 'paddq';
PALIGNR           : 'palignr';
PAVGB             : 'pavgb';
PAVGW             : 'pavgw';
PBLENDVB          : 'pblendvb';
PBLENDW           : 'pblendw';
PCLMULHQHQDQ      : 'pclmulhqhqdq';
PCLMULHQLQDQ      : 'pclmulhqlqdq';
PCLMULLQHQDQ      : 'pclmullqhqdq';
PCLMULLQLQDQ      : 'pclmullqlqdq';
PCLMULQDQ         : 'pclmulqdq';
PCMPEQQ           : 'pcmpeqq';
PCMPESTRI         : 'pcmpestri';
PCMPESTRM         : 'pcmpestrm';
PCMPGTQ           : 'pcmpgtq';
PCMPISTRI         : 'pcmpistri';
PCMPISTRM         : 'pcmpistrm';
PCOMMIT           : 'pcommit';
PCONFIG           : 'pconfig';
PDEP              : 'pdep';
PEXT              : 'pext';
PEXTRB            : 'pextrb';
PEXTRD            : 'pextrd';
PEXTRQ            : 'pextrq';
PEXTRW            : 'pextrw';
PF2IW             : 'pf2iw';
PFNACC            : 'pfnacc';
PFPNACC           : 'pfpnacc';
PFRCPV            : 'pfrcpv';
PFRSQRTV          : 'pfrsqrtv';
PHADDD            : 'phaddd';
PHADDSW           : 'phaddsw';
PHADDW            : 'phaddw';
PHMINPOSUW        : 'phminposuw';
PHSUBD            : 'phsubd';
PHSUBSW           : 'phsubsw';
PHSUBW            : 'phsubw';
PI2FW             : 'pi2fw';
PINSRB            : 'pinsrb';
PINSRD            : 'pinsrd';
PINSRQ            : 'pinsrq';
PINSRW            : 'pinsrw';
PMADDUBSW         : 'pmaddubsw';
PMAXSB            : 'pmaxsb';
PMAXSD            : 'pmaxsd';
PMAXSW            : 'pmaxsw';
PMAXUB            : 'pmaxub';
PMAXUD            : 'pmaxud';
PMAXUW            : 'pmaxuw';
PMINSB            : 'pminsb';
PMINSD            : 'pminsd';
PMINSW            : 'pminsw';
PMINUB            : 'pminub';
PMINUD            : 'pminud';
PMINUW            : 'pminuw';
PMOVMSKB          : 'pmovmskb';
PMOVSXBD          : 'pmovsxbd';
PMOVSXBQ          : 'pmovsxbq';
PMOVSXBW          : 'pmovsxbw';
PMOVSXDQ          : 'pmovsxdq';
PMOVSXWD          : 'pmovsxwd';
PMOVSXWQ          : 'pmovsxwq';
PMOVZXBD          : 'pmovzxbd';
PMOVZXBQ          : 'pmovzxbq';
PMOVZXBW          : 'pmovzxbw';
PMOVZXDQ          : 'pmovzxdq';
PMOVZXWD          : 'pmovzxwd';
PMOVZXWQ          : 'pmovzxwq';
PMULDQ            : 'pmuldq';
PMULHRSW          : 'pmulhrsw';
PMULHUW           : 'pmulhuw';
PMULLD            : 'pmulld';
PMULUDQ           : 'pmuludq';
POPCNT            : 'popcnt';
PREFETCHIT0       : 'prefetchit0';
PREFETCHIT1       : 'prefetchit1';
PREFETCHNTA       : 'prefetchnta';
PREFETCHT0        : 'prefetcht0';
PREFETCHT1        : 'prefetcht1';
PREFETCHT2        : 'prefetcht2';
PREFETCHWT1       : 'prefetchwt1';
PSADBW            : 'psadbw';
PSHUFB            : 'pshufb';
PSHUFD            : 'pshufd';
PSHUFHW           : 'pshufhw';
PSHUFLW           : 'pshuflw';
PSHUFW            : 'pshufw';
PSIGNB            : 'psignb';
PSIGND            : 'psignd';
PSIGNW            : 'psignw';
PSLLDQ            : 'pslldq';
PSRLDQ            : 'psrldq';
PSUBQ             : 'psubq';
PSWAPD            : 'pswapd';
PTEST             : 'ptest';
PTWRITE           : 'ptwrite';
PUNPCKHQDQ        : 'punpckhqdq';
PUNPCKLQDQ        : 'punpcklqdq';
PVALIDATE         : 'pvalidate';
RCPPS             : 'rcpps';
RCPSS             : 'rcpss';
RDFSBASE          : 'rdfsbase';
RDGSBASE          : 'rdgsbase';
RDMSRLIST         : 'rdmsrlist';
RDPID             : 'rdpid';
RDPKRU            : 'rdpkru';
RDRAND            : 'rdrand';
RDSEED            : 'rdseed';
RDSSPD            : 'rdsspd';
RDSSPQ            : 'rdsspq';
RMPADJUST         : 'rmpadjust';
RORX              : 'rorx';
ROUNDPD           : 'roundpd';
ROUNDPS           : 'roundps';
ROUNDSD           : 'roundsd';
ROUNDSS           : 'roundss';
RSQRTPS           : 'rsqrtps';
RSQRTSS           : 'rsqrtss';
RSTORSSP          : 'rstorssp';
SARX              : 'sarx';
SAVEPREVSSP       : 'saveprevssp';
SENDUIPI          : 'senduipi';
SERIALIZE         : 'serialize';
SETSSBSY          : 'setssbsy';
SHA1MSG1          : 'sha1msg1';
SHA1MSG2          : 'sha1msg2';
SHA1NEXTE         : 'sha1nexte';
SHA1RNDS4         : 'sha1rnds4';
SHA256MSG1        : 'sha256msg1';
SHA256MSG2        : 'sha256msg2';
SHA256RNDS2       : 'sha256rnds2';
SHLX              : 'shlx';
SHRX              : 'shrx';
SHUFPD            : 'shufpd';
SHUFPS            : 'shufps';
SLWPCB            : 'slwpcb';
SQRTPD            : 'sqrtpd';
SQRTPS            : 'sqrtps';
SQRTSD            : 'sqrtsd';
SQRTSS            : 'sqrtss';
STAC              : 'stac';
STGI              : 'stgi';
STMXCSR           : 'stmxcsr';
STTILECFG         : 'sttilecfg';
STUI              : 'stui';
SUBPD             : 'subpd';
SUBPS             : 'subps';
SUBSD             : 'subsd';
SUBSS             : 'subss';
T1MSKC            : 't1mskc';
TDPBF16PS         : 'tdpbf16ps';
TDPBSSD           : 'tdpbssd';
TDPBSUD           : 'tdpbsud';
TDPBUSD           : 'tdpbusd';
TDPBUUD           : 'tdpbuud';
TESTUI            : 'testui';
TILELOADD         : 'tileloadd';
TILELOADDT1       : 'tileloaddt1';
TILERELEASE       : 'tilerelease';
TILESTORED        : 'tilestored';
TILEZERO          : 'tilezero';
TPAUSE            : 'tpause';
TZCNT             : 'tzcnt';
TZMSK             : 'tzmsk';
UCOMISD           : 'ucomisd';
UCOMISS           : 'ucomiss';
UIRET             : 'uiret';
UMONITOR          : 'umonitor';
UMWAIT            : 'umwait';
UNPCKHPD          : 'unpckhpd';
UNPCKHPS          : 'unpckhps';
UNPCKLPD          : 'unpcklpd';
UNPCKLPS          : 'unpcklps';
V4DPWSSD          : 'v4dpwssd';
V4DPWSSDS         : 'v4dpwssds';
V4FMADDPS         : 'v4fmaddps';
V4FMADDSS         : 'v4fmaddss';
V4FNMADDPS        : 'v4fnmaddps';
V4FNMADDSS        : 'v4fnmaddss';
VADDPD            : 'vaddpd';
VADDPH            : 'vaddph';
VADDPS            : 'vaddps';
VADDSD            : 'vaddsd';
VADDSH            : 'vaddsh';
VADDSS            : 'vaddss';
VADDSUBPD         : 'vaddsubpd';
VADDSUBPS         : 'vaddsubps';
VAESDEC           : 'vaesdec';
VAESDECLAST       : 'vaesdeclast';
VAESENC           : 'vaesenc';
VAESENCLAST       : 'vaesenclast';
VAESIMC           : 'vaesimc';
VAESKEYGENASSIST  : 'vaeskeygenassist';
VALIGND           : 'valignd';
VALIGNQ           : 'valignq';
VANDNPD           : 'vandnpd';
VANDNPS           : 'vandnps';
VANDPD            : 'vandpd';
VANDPS            : 'vandps';
VBCSTNEBF16PS     : 'vbcstnebf16ps';
VBCSTNESH2PS      : 'vbcstnesh2ps';
VBLENDMPD         : 'vblendmpd';
VBLENDMPS         : 'vblendmps';
VBLENDPD          : 'vblendpd';
VBLENDPS          : 'vblendps';
VBLENDVPD         : 'vblendvpd';
VBLENDVPS         : 'vblendvps';
VBROADCASTF128    : 'vbroadcastf128';
VBROADCASTF32X2   : 'vbroadcastf32x2';
VBROADCASTF32X4   : 'vbroadcastf32x4';
VBROADCASTF32X8   : 'vbroadcastf32x8';
VBROADCASTF64X2   : 'vbroadcastf64x2';
VBROADCASTF64X4   : 'vbroadcastf64x4';
VBROADCASTI128    : 'vbroadcasti128';
VBROADCASTI32X2   : 'vbroadcasti32x2';
VBROADCASTI32X4   : 'vbroadcasti32x4';
VBROADCASTI32X8   : 'vbroadcasti32x8';
VBROADCASTI64X2   : 'vbroadcasti64x2';
VBROADCASTI64X4   : 'vbroadcasti64x4';
VBROADCASTSD      : 'vbroadcastsd';
VBROADCASTSS      : 'vbroadcastss';
VCMPEQ_OQPD       : 'vcmpeq_oqpd';
VCMPEQ_OQPS       : 'vcmpeq_oqps';
VCMPEQ_OQSD       : 'vcmpeq_oqsd';
VCMPEQ_OQSS       : 'vcmpeq_oqss';
VCMPEQ_OSPD       : 'vcmpeq_ospd';
VCMPEQ_OSPS       : 'vcmpeq_osps';
VCMPEQ_OSSD       : 'vcmpeq_ossd';
VCMPEQ_OSSS       : 'vcmpeq_osss';
VCMPEQ_UQPD       : 'vcmpeq_uqpd';
VCMPEQ_UQPS       : 'vcmpeq_uqps';
VCMPEQ_UQSD       : 'vcmpeq_uqsd';
VCMPEQ_UQSS       : 'vcmpeq_uqss';
VCMPEQ_USPD       : 'vcmpeq_uspd';
VCMPEQ_USPS       : 'vcmpeq_usps';
VCMPEQ_USSD       : 'vcmpeq_ussd';
VCMPEQ_USSS       : 'vcmpeq_usss';
VCMPEQPD          : 'vcmpeqpd';
VCMPEQPS          : 'vcmpeqps';
VCMPEQSD          : 'vcmpeqsd';
VCMPEQSS          : 'vcmpeqss';
VCMPFALSE_OQPD    : 'vcmpfalse_oqpd';
VCMPFALSE_OQPS    : 'vcmpfalse_oqps';
VCMPFALSE_OQSD    : 'vcmpfalse_oqsd';
VCMPFALSE_OQSS    : 'vcmpfalse_oqss';
VCMPFALSE_OSPD    : 'vcmpfalse_ospd';
VCMPFALSE_OSPS    : 'vcmpfalse_osps';
VCMPFALSE_OSSD    : 'vcmpfalse_ossd';
VCMPFALSE_OSSS    : 'vcmpfalse_osss';
VCMPFALSEPD       : 'vcmpfalsepd';
VCMPFALSEPS       : 'vcmpfalseps';
VCMPFALSESD       : 'vcmpfalsesd';
VCMPFALSESS       : 'vcmpfalsess';
VCMPGE_OQPD       : 'vcmpge_oqpd';
VCMPGE_OQPS       : 'vcmpge_oqps';
VCMPGE_OQSD       : 'vcmpge_oqsd';
VCMPGE_OQSS       : 'vcmpge_oqss';
VCMPGE_OSPD       : 'vcmpge_ospd';
VCMPGE_OSPS       : 'vcmpge_osps';
VCMPGE_OSSD       : 'vcmpge_ossd';
VCMPGE_OSSS       : 'vcmpge_osss';
VCMPGEPD          : 'vcmpgepd';
VCMPGEPS          : 'vcmpgeps';
VCMPGESD          : 'vcmpgesd';
VCMPGESS          : 'vcmpgess';
VCMPGT_OQPD       : 'vcmpgt_oqpd';
VCMPGT_OQPS       : 'vcmpgt_oqps';
VCMPGT_OQSD       : 'vcmpgt_oqsd';
VCMPGT_OQSS       : 'vcmpgt_oqss';
VCMPGT_OSPD       : 'vcmpgt_ospd';
VCMPGT_OSPS       : 'vcmpgt_osps';
VCMPGT_OSSD       : 'vcmpgt_ossd';
VCMPGT_OSSS       : 'vcmpgt_osss';
VCMPGTPD          : 'vcmpgtpd';
VCMPGTPS          : 'vcmpgtps';
VCMPGTSD          : 'vcmpgtsd';
VCMPGTSS          : 'vcmpgtss';
VCMPLE_OQPD       : 'vcmple_oqpd';
VCMPLE_OQPS       : 'vcmple_oqps';
VCMPLE_OQSD       : 'vcmple_oqsd';
VCMPLE_OQSS       : 'vcmple_oqss';
VCMPLE_OSPD       : 'vcmple_ospd';
VCMPLE_OSPS       : 'vcmple_osps';
VCMPLE_OSSD       : 'vcmple_ossd';
VCMPLE_OSSS       : 'vcmple_osss';
VCMPLEPD          : 'vcmplepd';
VCMPLEPS          : 'vcmpleps';
VCMPLESD          : 'vcmplesd';
VCMPLESS          : 'vcmpless';
VCMPLT_OQPD       : 'vcmplt_oqpd';
VCMPLT_OQPS       : 'vcmplt_oqps';
VCMPLT_OQSD       : 'vcmplt_oqsd';
VCMPLT_OQSS       : 'vcmplt_oqss';
VCMPLT_OSPD       : 'vcmplt_ospd';
VCMPLT_OSPS       : 'vcmplt_osps';
VCMPLT_OSSD       : 'vcmplt_ossd';
VCMPLT_OSSS       : 'vcmplt_osss';
VCMPLTPD          : 'vcmpltpd';
VCMPLTPS          : 'vcmpltps';
VCMPLTSD          : 'vcmpltsd';
VCMPLTSS          : 'vcmpltss';
VCMPNEQ_OQPD      : 'vcmpneq_oqpd';
VCMPNEQ_OQPS      : 'vcmpneq_oqps';
VCMPNEQ_OQSD      : 'vcmpneq_oqsd';
VCMPNEQ_OQSS      : 'vcmpneq_oqss';
VCMPNEQ_OSPD      : 'vcmpneq_ospd';
VCMPNEQ_OSPS      : 'vcmpneq_osps';
VCMPNEQ_OSSD      : 'vcmpneq_ossd';
VCMPNEQ_OSSS      : 'vcmpneq_osss';
VCMPNEQ_UQPD      : 'vcmpneq_uqpd';
VCMPNEQ_UQPS      : 'vcmpneq_uqps';
VCMPNEQ_UQSD      : 'vcmpneq_uqsd';
VCMPNEQ_UQSS      : 'vcmpneq_uqss';
VCMPNEQ_USPD      : 'vcmpneq_uspd';
VCMPNEQ_USPS      : 'vcmpneq_usps';
VCMPNEQ_USSD      : 'vcmpneq_ussd';
VCMPNEQ_USSS      : 'vcmpneq_usss';
VCMPNEQPD         : 'vcmpneqpd';
VCMPNEQPS         : 'vcmpneqps';
VCMPNEQSD         : 'vcmpneqsd';
VCMPNEQSS         : 'vcmpneqss';
VCMPNGE_UQPD      : 'vcmpnge_uqpd';
VCMPNGE_UQPS      : 'vcmpnge_uqps';
VCMPNGE_UQSD      : 'vcmpnge_uqsd';
VCMPNGE_UQSS      : 'vcmpnge_uqss';
VCMPNGE_USPD      : 'vcmpnge_uspd';
VCMPNGE_USPS      : 'vcmpnge_usps';
VCMPNGE_USSD      : 'vcmpnge_ussd';
VCMPNGE_USSS      : 'vcmpnge_usss';
VCMPNGEPD         : 'vcmpngepd';
VCMPNGEPS         : 'vcmpngeps';
VCMPNGESD         : 'vcmpngesd';
VCMPNGESS         : 'vcmpngess';
VCMPNGT_UQPD      : 'vcmpngt_uqpd';
VCMPNGT_UQPS      : 'vcmpngt_uqps';
VCMPNGT_UQSD      : 'vcmpngt_uqsd';
VCMPNGT_UQSS      : 'vcmpngt_uqss';
VCMPNGT_USPD      : 'vcmpngt_uspd';
VCMPNGT_USPS      : 'vcmpngt_usps';
VCMPNGT_USSD      : 'vcmpngt_ussd';
VCMPNGT_USSS      : 'vcmpngt_usss';
VCMPNGTPD         : 'vcmpngtpd';
VCMPNGTPS         : 'vcmpngtps';
VCMPNGTSD         : 'vcmpngtsd';
VCMPNGTSS         : 'vcmpngtss';
VCMPNLE_UQPD      : 'vcmpnle_uqpd';
VCMPNLE_UQPS      : 'vcmpnle_uqps';
VCMPNLE_UQSD      : 'vcmpnle_uqsd';
VCMPNLE_UQSS      : 'vcmpnle_uqss';
VCMPNLE_USPD      : 'vcmpnle_uspd';
VCMPNLE_USPS      : 'vcmpnle_usps';
VCMPNLE_USSD      : 'vcmpnle_ussd';
VCMPNLE_USSS      : 'vcmpnle_usss';
VCMPNLEPD         : 'vcmpnlepd';
VCMPNLEPS         : 'vcmpnleps';
VCMPNLESD         : 'vcmpnlesd';
VCMPNLESS         : 'vcmpnless';
VCMPNLT_UQPD      : 'vcmpnlt_uqpd';
VCMPNLT_UQPS      : 'vcmpnlt_uqps';
VCMPNLT_UQSD      : 'vcmpnlt_uqsd';
VCMPNLT_UQSS      : 'vcmpnlt_uqss';
VCMPNLT_USPD      : 'vcmpnlt_uspd';
VCMPNLT_USPS      : 'vcmpnlt_usps';
VCMPNLT_USSD      : 'vcmpnlt_ussd';
VCMPNLT_USSS      : 'vcmpnlt_usss';
VCMPNLTPD         : 'vcmpnltpd';
VCMPNLTPS         : 'vcmpnltps';
VCMPNLTSD         : 'vcmpnltsd';
VCMPNLTSS         : 'vcmpnltss';
VCMPORD_QPD       : 'vcmpord_qpd';
VCMPORD_QPS       : 'vcmpord_qps';
VCMPORD_QSD       : 'vcmpord_qsd';
VCMPORD_QSS       : 'vcmpord_qss';
VCMPORD_SPD       : 'vcmpord_spd';
VCMPORD_SPS       : 'vcmpord_sps';
VCMPORD_SSD       : 'vcmpord_ssd';
VCMPORD_SSS       : 'vcmpord_sss';
VCMPORDPD         : 'vcmpordpd';
VCMPORDPS         : 'vcmpordps';
VCMPORDSD         : 'vcmpordsd';
VCMPORDSS         : 'vcmpordss';
VCMPPD            : 'vcmppd';
VCMPPH            : 'vcmpph';
VCMPPS            : 'vcmpps';
VCMPSD            : 'vcmpsd';
VCMPSH            : 'vcmpsh';
VCMPSS            : 'vcmpss';
VCMPTRUE_UQPD     : 'vcmptrue_uqpd';
VCMPTRUE_UQPS     : 'vcmptrue_uqps';
VCMPTRUE_UQSD     : 'vcmptrue_uqsd';
VCMPTRUE_UQSS     : 'vcmptrue_uqss';
VCMPTRUE_USPD     : 'vcmptrue_uspd';
VCMPTRUE_USPS     : 'vcmptrue_usps';
VCMPTRUE_USSD     : 'vcmptrue_ussd';
VCMPTRUE_USSS     : 'vcmptrue_usss';
VCMPTRUEPD        : 'vcmptruepd';
VCMPTRUEPS        : 'vcmptrueps';
VCMPTRUESD        : 'vcmptruesd';
VCMPTRUESS        : 'vcmptruess';
VCMPUNORD_QPD     : 'vcmpunord_qpd';
VCMPUNORD_QPS     : 'vcmpunord_qps';
VCMPUNORD_QSD     : 'vcmpunord_qsd';
VCMPUNORD_QSS     : 'vcmpunord_qss';
VCMPUNORD_SPD     : 'vcmpunord_spd';
VCMPUNORD_SPS     : 'vcmpunord_sps';
VCMPUNORD_SSD     : 'vcmpunord_ssd';
VCMPUNORD_SSS     : 'vcmpunord_sss';
VCMPUNORDPD       : 'vcmpunordpd';
VCMPUNORDPS       : 'vcmpunordps';
VCMPUNORDSD       : 'vcmpunordsd';
VCMPUNORDSS       : 'vcmpunordss';
VCOMISD           : 'vcomisd';
VCOMISH           : 'vcomish';
VCOMISS           : 'vcomiss';
VCOMPRESSPD       : 'vcompresspd';
VCOMPRESSPS       : 'vcompressps';
VCVTDQ2PD         : 'vcvtdq2pd';
VCVTDQ2PH         : 'vcvtdq2ph';
VCVTDQ2PS         : 'vcvtdq2ps';
VCVTNE2PS2BF16    : 'vcvtne2ps2bf16';
VCVTNEEBF162PS    : 'vcvtneebf162ps';
VCVTNEEPH2PS      : 'vcvtneeph2ps';
VCVTNEOBF162PS    : 'vcvtneobf162ps';
VCVTNEOPH2PS      : 'vcvtneoph2ps';
VCVTNEPS2BF16     : 'vcvtneps2bf16';
VCVTPD2DQ         : 'vcvtpd2dq';
VCVTPD2PH         : 'vcvtpd2ph';
VCVTPD2PS         : 'vcvtpd2ps';
VCVTPD2QQ         : 'vcvtpd2qq';
VCVTPD2UDQ        : 'vcvtpd2udq';
VCVTPD2UQQ        : 'vcvtpd2uqq';
VCVTPH2DQ         : 'vcvtph2dq';
VCVTPH2PD         : 'vcvtph2pd';
VCVTPH2PS         : 'vcvtph2ps';
VCVTPH2PSX        : 'vcvtph2psx';
VCVTPH2QQ         : 'vcvtph2qq';
VCVTPH2UDQ        : 'vcvtph2udq';
VCVTPH2UQQ        : 'vcvtph2uqq';
VCVTPH2UW         : 'vcvtph2uw';
VCVTPH2W          : 'vcvtph2w';
VCVTPS2DQ         : 'vcvtps2dq';
VCVTPS2PD         : 'vcvtps2pd';
VCVTPS2PH         : 'vcvtps2ph';
VCVTPS2QQ         : 'vcvtps2qq';
VCVTPS2UDQ        : 'vcvtps2udq';
VCVTPS2UQQ        : 'vcvtps2uqq';
VCVTQQ2PD         : 'vcvtqq2pd';
VCVTQQ2PH         : 'vcvtqq2ph';
VCVTQQ2PS         : 'vcvtqq2ps';
VCVTSD2SH         : 'vcvtsd2sh';
VCVTSD2SI         : 'vcvtsd2si';
VCVTSD2SS         : 'vcvtsd2ss';
VCVTSD2USI        : 'vcvtsd2usi';
VCVTSH2SD         : 'vcvtsh2sd';
VCVTSH2SI         : 'vcvtsh2si';
VCVTSH2SS         : 'vcvtsh2ss';
VCVTSH2USI        : 'vcvtsh2usi';
VCVTSI2SD         : 'vcvtsi2sd';
VCVTSI2SH         : 'vcvtsi2sh';
VCVTSI2SS         : 'vcvtsi2ss';
VCVTSS2SD         : 'vcvtss2sd';
VCVTSS2SH         : 'vcvtss2sh';
VCVTSS2SI         : 'vcvtss2si';
VCVTSS2USI        : 'vcvtss2usi';
VCVTTPD2DQ        : 'vcvttpd2dq';
VCVTTPD2QQ        : 'vcvttpd2qq';
VCVTTPD2UDQ       : 'vcvttpd2udq';
VCVTTPD2UQQ       : 'vcvttpd2uqq';
VCVTTPH2DQ        : 'vcvttph2dq';
VCVTTPH2QQ        : 'vcvttph2qq';
VCVTTPH2UDQ       : 'vcvttph2udq';
VCVTTPH2UQQ       : 'vcvttph2uqq';
VCVTTPH2UW        : 'vcvttph2uw';
VCVTTPH2W         : 'vcvttph2w';
VCVTTPS2DQ        : 'vcvttps2dq';
VCVTTPS2QQ        : 'vcvttps2qq';
VCVTTPS2UDQ       : 'vcvttps2udq';
VCVTTPS2UQQ       : 'vcvttps2uqq';
VCVTTSD2SI        : 'vcvttsd2si';
VCVTTSD2USI       : 'vcvttsd2usi';
VCVTTSH2SI        : 'vcvttsh2si';
VCVTTSH2USI       : 'vcvttsh2usi';
VCVTTSS2SI        : 'vcvttss2si';
VCVTTSS2USI       : 'vcvttss2usi';
VCVTUDQ2PD        : 'vcvtudq2pd';
VCVTUDQ2PH        : 'vcvtudq2ph';
VCVTUDQ2PS        : 'vcvtudq2ps';
VCVTUQQ2PD        : 'vcvtuqq2pd';
VCVTUQQ2PH        : 'vcvtuqq2ph';
VCVTUQQ2PS        : 'vcvtuqq2ps';
VCVTUSI2SD        : 'vcvtusi2sd';
VCVTUSI2SH        : 'vcvtusi2sh';
VCVTUSI2SS        : 'vcvtusi2ss';
VCVTUW2PH         : 'vcvtuw2ph';
VCVTW2PH          : 'vcvtw2ph';
VDBPSADBW         : 'vdbpsadbw';
VDIVPD            : 'vdivpd';
VDIVPH            : 'vdivph';
VDIVPS            : 'vdivps';
VDIVSD            : 'vdivsd';
VDIVSH            : 'vdivsh';
VDIVSS            : 'vdivss';
VDPBF16PS         : 'vdpbf16ps';
VDPPD             : 'vdppd';
VDPPS             : 'vdpps';
VENDSCALEPH       : 'vendscaleph';
VENDSCALESH       : 'vendscalesh';
VEXP2PD           : 'vexp2pd';
VEXP2PS           : 'vexp2ps';
VEXPANDPD         : 'vexpandpd';
VEXPANDPS         : 'vexpandps';
VEXTRACTF128      : 'vextractf128';
VEXTRACTF32X4     : 'vextractf32x4';
VEXTRACTF32X8     : 'vextractf32x8';
VEXTRACTF64X2     : 'vextractf64x2';
VEXTRACTF64X4     : 'vextractf64x4';
VEXTRACTI128      : 'vextracti128';
VEXTRACTI32X4     : 'vextracti32x4';
VEXTRACTI32X8     : 'vextracti32x8';
VEXTRACTI64X2     : 'vextracti64x2';
VEXTRACTI64X4     : 'vextracti64x4';
VEXTRACTPS        : 'vextractps';
VFCMADDCPH        : 'vfcmaddcph';
VFCMADDCSH        : 'vfcmaddcsh';
VFCMULCPCH        : 'vfcmulcpch';
VFCMULCSH         : 'vfcmulcsh';
VFIXUPIMMPD       : 'vfixupimmpd';
VFIXUPIMMPS       : 'vfixupimmps';
VFIXUPIMMSD       : 'vfixupimmsd';
VFIXUPIMMSS       : 'vfixupimmss';
VFMADD123PD       : 'vfmadd123pd';
VFMADD123PS       : 'vfmadd123ps';
VFMADD123SD       : 'vfmadd123sd';
VFMADD123SS       : 'vfmadd123ss';
VFMADD132PD       : 'vfmadd132pd';
VFMADD132PH       : 'vfmadd132ph';
VFMADD132PS       : 'vfmadd132ps';
VFMADD132SD       : 'vfmadd132sd';
VFMADD132SS       : 'vfmadd132ss';
VFMADD213PD       : 'vfmadd213pd';
VFMADD213PH       : 'vfmadd213ph';
VFMADD213PS       : 'vfmadd213ps';
VFMADD213SD       : 'vfmadd213sd';
VFMADD213SS       : 'vfmadd213ss';
VFMADD231PD       : 'vfmadd231pd';
VFMADD231PH       : 'vfmadd231ph';
VFMADD231PS       : 'vfmadd231ps';
VFMADD231SD       : 'vfmadd231sd';
VFMADD231SS       : 'vfmadd231ss';
VFMADD312PD       : 'vfmadd312pd';
VFMADD312PS       : 'vfmadd312ps';
VFMADD312SD       : 'vfmadd312sd';
VFMADD312SS       : 'vfmadd312ss';
VFMADD321PD       : 'vfmadd321pd';
VFMADD321PS       : 'vfmadd321ps';
VFMADD321SD       : 'vfmadd321sd';
VFMADD321SS       : 'vfmadd321ss';
VFMADDCPH         : 'vfmaddcph';
VFMADDCSH         : 'vfmaddcsh';
VFMADDPD          : 'vfmaddpd';
VFMADDPS          : 'vfmaddps';
VFMADDSD          : 'vfmaddsd';
VFMADDSS          : 'vfmaddss';
VFMADDSUB123PD    : 'vfmaddsub123pd';
VFMADDSUB123PS    : 'vfmaddsub123ps';
VFMADDSUB132PD    : 'vfmaddsub132pd';
VFMADDSUB132PH    : 'vfmaddsub132ph';
VFMADDSUB132PS    : 'vfmaddsub132ps';
VFMADDSUB213PD    : 'vfmaddsub213pd';
VFMADDSUB213PH    : 'vfmaddsub213ph';
VFMADDSUB213PS    : 'vfmaddsub213ps';
VFMADDSUB231PD    : 'vfmaddsub231pd';
VFMADDSUB231PH    : 'vfmaddsub231ph';
VFMADDSUB231PS    : 'vfmaddsub231ps';
VFMADDSUB312PD    : 'vfmaddsub312pd';
VFMADDSUB312PS    : 'vfmaddsub312ps';
VFMADDSUB321PD    : 'vfmaddsub321pd';
VFMADDSUB321PS    : 'vfmaddsub321ps';
VFMADDSUBPD       : 'vfmaddsubpd';
VFMADDSUBPS       : 'vfmaddsubps';
VFMSUB123PD       : 'vfmsub123pd';
VFMSUB123PS       : 'vfmsub123ps';
VFMSUB123SD       : 'vfmsub123sd';
VFMSUB123SS       : 'vfmsub123ss';
VFMSUB132PD       : 'vfmsub132pd';
VFMSUB132PH       : 'vfmsub132ph';
VFMSUB132PS       : 'vfmsub132ps';
VFMSUB132SD       : 'vfmsub132sd';
VFMSUB132SS       : 'vfmsub132ss';
VFMSUB213PD       : 'vfmsub213pd';
VFMSUB213PH       : 'vfmsub213ph';
VFMSUB213PS       : 'vfmsub213ps';
VFMSUB213SD       : 'vfmsub213sd';
VFMSUB213SS       : 'vfmsub213ss';
VFMSUB231PD       : 'vfmsub231pd';
VFMSUB231PH       : 'vfmsub231ph';
VFMSUB231PS       : 'vfmsub231ps';
VFMSUB231SD       : 'vfmsub231sd';
VFMSUB231SS       : 'vfmsub231ss';
VFMSUB312PD       : 'vfmsub312pd';
VFMSUB312PS       : 'vfmsub312ps';
VFMSUB312SD       : 'vfmsub312sd';
VFMSUB312SS       : 'vfmsub312ss';
VFMSUB321PD       : 'vfmsub321pd';
VFMSUB321PS       : 'vfmsub321ps';
VFMSUB321SD       : 'vfmsub321sd';
VFMSUB321SS       : 'vfmsub321ss';
VFMSUBADD123PD    : 'vfmsubadd123pd';
VFMSUBADD123PS    : 'vfmsubadd123ps';
VFMSUBADD132PD    : 'vfmsubadd132pd';
VFMSUBADD132PH    : 'vfmsubadd132ph';
VFMSUBADD132PS    : 'vfmsubadd132ps';
VFMSUBADD213PD    : 'vfmsubadd213pd';
VFMSUBADD213PH    : 'vfmsubadd213ph';
VFMSUBADD213PS    : 'vfmsubadd213ps';
VFMSUBADD231PD    : 'vfmsubadd231pd';
VFMSUBADD231PH    : 'vfmsubadd231ph';
VFMSUBADD231PS    : 'vfmsubadd231ps';
VFMSUBADD312PD    : 'vfmsubadd312pd';
VFMSUBADD312PS    : 'vfmsubadd312ps';
VFMSUBADD321PD    : 'vfmsubadd321pd';
VFMSUBADD321PS    : 'vfmsubadd321ps';
VFMSUBADDPD       : 'vfmsubaddpd';
VFMSUBADDPS       : 'vfmsubaddps';
VFMSUBPD          : 'vfmsubpd';
VFMSUBPS          : 'vfmsubps';
VFMSUBSD          : 'vfmsubsd';
VFMSUBSS          : 'vfmsubss';
VFMULCPCH         : 'vfmulcpch';
VFMULCSH          : 'vfmulcsh';
VFNMADD123PD      : 'vfnmadd123pd';
VFNMADD123PS      : 'vfnmadd123ps';
VFNMADD123SD      : 'vfnmadd123sd';
VFNMADD123SS      : 'vfnmadd123ss';
VFNMADD132PD      : 'vfnmadd132pd';
VFNMADD132PS      : 'vfnmadd132ps';
VFNMADD132SD      : 'vfnmadd132sd';
VFNMADD132SS      : 'vfnmadd132ss';
VFNMADD213PD      : 'vfnmadd213pd';
VFNMADD213PS      : 'vfnmadd213ps';
VFNMADD213SD      : 'vfnmadd213sd';
VFNMADD213SS      : 'vfnmadd213ss';
VFNMADD231PD      : 'vfnmadd231pd';
VFNMADD231PS      : 'vfnmadd231ps';
VFNMADD231SD      : 'vfnmadd231sd';
VFNMADD231SS      : 'vfnmadd231ss';
VFNMADD312PD      : 'vfnmadd312pd';
VFNMADD312PS      : 'vfnmadd312ps';
VFNMADD312SD      : 'vfnmadd312sd';
VFNMADD312SS      : 'vfnmadd312ss';
VFNMADD321PD      : 'vfnmadd321pd';
VFNMADD321PS      : 'vfnmadd321ps';
VFNMADD321SD      : 'vfnmadd321sd';
VFNMADD321SS      : 'vfnmadd321ss';
VFNMADDPD         : 'vfnmaddpd';
VFNMADDPS         : 'vfnmaddps';
VFNMADDSD         : 'vfnmaddsd';
VFNMADDSS         : 'vfnmaddss';
VFNMSUB123PD      : 'vfnmsub123pd';
VFNMSUB123PS      : 'vfnmsub123ps';
VFNMSUB123SD      : 'vfnmsub123sd';
VFNMSUB123SS      : 'vfnmsub123ss';
VFNMSUB132PD      : 'vfnmsub132pd';
VFNMSUB132PS      : 'vfnmsub132ps';
VFNMSUB132SD      : 'vfnmsub132sd';
VFNMSUB132SS      : 'vfnmsub132ss';
VFNMSUB213PD      : 'vfnmsub213pd';
VFNMSUB213PS      : 'vfnmsub213ps';
VFNMSUB213SD      : 'vfnmsub213sd';
VFNMSUB213SS      : 'vfnmsub213ss';
VFNMSUB231PD      : 'vfnmsub231pd';
VFNMSUB231PS      : 'vfnmsub231ps';
VFNMSUB231SD      : 'vfnmsub231sd';
VFNMSUB231SS      : 'vfnmsub231ss';
VFNMSUB312PD      : 'vfnmsub312pd';
VFNMSUB312PS      : 'vfnmsub312ps';
VFNMSUB312SD      : 'vfnmsub312sd';
VFNMSUB312SS      : 'vfnmsub312ss';
VFNMSUB321PD      : 'vfnmsub321pd';
VFNMSUB321PS      : 'vfnmsub321ps';
VFNMSUB321SD      : 'vfnmsub321sd';
VFNMSUB321SS      : 'vfnmsub321ss';
VFNMSUBPD         : 'vfnmsubpd';
VFNMSUBPS         : 'vfnmsubps';
VFNMSUBSD         : 'vfnmsubsd';
VFNMSUBSS         : 'vfnmsubss';
VFPCLASSPD        : 'vfpclasspd';
VFPCLASSPH        : 'vfpclassph';
VFPCLASSPS        : 'vfpclassps';
VFPCLASSSD        : 'vfpclasssd';
VFPCLASSSH        : 'vfpclasssh';
VFPCLASSSS        : 'vfpclassss';
VFRCZPD           : 'vfrczpd';
VFRCZPS           : 'vfrczps';
VFRCZSD           : 'vfrczsd';
VFRCZSS           : 'vfrczss';
VGATHERDPD        : 'vgatherdpd';
VGATHERDPS        : 'vgatherdps';
VGATHERPF0DPD     : 'vgatherpf0dpd';
VGATHERPF0DPS     : 'vgatherpf0dps';
VGATHERPF0QPD     : 'vgatherpf0qpd';
VGATHERPF0QPS     : 'vgatherpf0qps';
VGATHERPF1DPD     : 'vgatherpf1dpd';
VGATHERPF1DPS     : 'vgatherpf1dps';
VGATHERPF1QPD     : 'vgatherpf1qpd';
VGATHERPF1QPS     : 'vgatherpf1qps';
VGATHERQPD        : 'vgatherqpd';
VGATHERQPS        : 'vgatherqps';
VGETEXPPD         : 'vgetexppd';
VGETEXPPH         : 'vgetexpph';
VGETEXPPS         : 'vgetexpps';
VGETEXPSD         : 'vgetexpsd';
VGETEXPSH         : 'vgetexpsh';
VGETEXPSS         : 'vgetexpss';
VGETMANTPD        : 'vgetmantpd';
VGETMANTPH        : 'vgetmantph';
VGETMANTPS        : 'vgetmantps';
VGETMANTSD        : 'vgetmantsd';
VGETMANTSH        : 'vgetmantsh';
VGETMANTSS        : 'vgetmantss';
VGETMAXPH         : 'vgetmaxph';
VGETMAXSH         : 'vgetmaxsh';
VGETMINPH         : 'vgetminph';
VGETMINSH         : 'vgetminsh';
VGF2P8AFFINEINVQB : 'vgf2p8affineinvqb';
VGF2P8AFFINEQB    : 'vgf2p8affineqb';
VGF2P8MULB        : 'vgf2p8mulb';
VHADDPD           : 'vhaddpd';
VHADDPS           : 'vhaddps';
VHSUBPD           : 'vhsubpd';
VHSUBPS           : 'vhsubps';
VINSERTF128       : 'vinsertf128';
VINSERTF32X4      : 'vinsertf32x4';
VINSERTF32X8      : 'vinsertf32x8';
VINSERTF64X2      : 'vinsertf64x2';
VINSERTF64X4      : 'vinsertf64x4';
VINSERTI128       : 'vinserti128';
VINSERTI32X4      : 'vinserti32x4';
VINSERTI32X8      : 'vinserti32x8';
VINSERTI64X2      : 'vinserti64x2';
VINSERTI64X4      : 'vinserti64x4';
VINSERTPS         : 'vinsertps';
VLDDQU            : 'vlddqu';
VLDMXCSR          : 'vldmxcsr';
VLDQQU            : 'vldqqu';
VMASKMOVDQU       : 'vmaskmovdqu';
VMASKMOVPD        : 'vmaskmovpd';
VMASKMOVPS        : 'vmaskmovps';
VMAXPD            : 'vmaxpd';
VMAXPS            : 'vmaxps';
VMAXSD            : 'vmaxsd';
VMAXSS            : 'vmaxss';
VMCALL            : 'vmcall';
VMCLEAR           : 'vmclear';
VMFUNC            : 'vmfunc';
VMGEXIT           : 'vmgexit';
VMINPD            : 'vminpd';
VMINPS            : 'vminps';
VMINSD            : 'vminsd';
VMINSS            : 'vminss';
VMLAUNCH          : 'vmlaunch';
VMLOAD            : 'vmload';
VMMCALL           : 'vmmcall';
VMOVAPD           : 'vmovapd';
VMOVAPS           : 'vmovaps';
VMOVD             : 'vmovd';
VMOVDDUP          : 'vmovddup';
VMOVDQA           : 'vmovdqa';
VMOVDQA32         : 'vmovdqa32';
VMOVDQA64         : 'vmovdqa64';
VMOVDQU           : 'vmovdqu';
VMOVDQU16         : 'vmovdqu16';
VMOVDQU32         : 'vmovdqu32';
VMOVDQU64         : 'vmovdqu64';
VMOVDQU8          : 'vmovdqu8';
VMOVHLPS          : 'vmovhlps';
VMOVHPD           : 'vmovhpd';
VMOVHPS           : 'vmovhps';
VMOVLHPS          : 'vmovlhps';
VMOVLPD           : 'vmovlpd';
VMOVLPS           : 'vmovlps';
VMOVMSKPD         : 'vmovmskpd';
VMOVMSKPS         : 'vmovmskps';
VMOVNTDQ          : 'vmovntdq';
VMOVNTDQA         : 'vmovntdqa';
VMOVNTPD          : 'vmovntpd';
VMOVNTPS          : 'vmovntps';
VMOVNTQQ          : 'vmovntqq';
VMOVQ             : 'vmovq';
VMOVQQA           : 'vmovqqa';
VMOVQQU           : 'vmovqqu';
VMOVSD            : 'vmovsd';
VMOVSH            : 'vmovsh';
VMOVSHDUP         : 'vmovshdup';
VMOVSLDUP         : 'vmovsldup';
VMOVSS            : 'vmovss';
VMOVUPD           : 'vmovupd';
VMOVUPS           : 'vmovups';
VMOVW             : 'vmovw';
VMPSADBW          : 'vmpsadbw';
VMPTRLD           : 'vmptrld';
VMPTRST           : 'vmptrst';
VMREAD            : 'vmread';
VMRESUME          : 'vmresume';
VMRUN             : 'vmrun';
VMSAVE            : 'vmsave';
VMULPD            : 'vmulpd';
VMULPH            : 'vmulph';
VMULPS            : 'vmulps';
VMULSD            : 'vmulsd';
VMULSH            : 'vmulsh';
VMULSS            : 'vmulss';
VMWRITE           : 'vmwrite';
VMXOFF            : 'vmxoff';
VMXON             : 'vmxon';
VORPD             : 'vorpd';
VORPS             : 'vorps';
VP2INTERSECTD     : 'vp2intersectd';
VPABSB            : 'vpabsb';
VPABSD            : 'vpabsd';
VPABSQ            : 'vpabsq';
VPABSW            : 'vpabsw';
VPACKSSDW         : 'vpackssdw';
VPACKSSWB         : 'vpacksswb';
VPACKUSDW         : 'vpackusdw';
VPACKUSWB         : 'vpackuswb';
VPADDB            : 'vpaddb';
VPADDD            : 'vpaddd';
VPADDQ            : 'vpaddq';
VPADDSB           : 'vpaddsb';
VPADDSW           : 'vpaddsw';
VPADDUSB          : 'vpaddusb';
VPADDUSW          : 'vpaddusw';
VPADDW            : 'vpaddw';
VPALIGNR          : 'vpalignr';
VPAND             : 'vpand';
VPANDD            : 'vpandd';
VPANDN            : 'vpandn';
VPANDND           : 'vpandnd';
VPANDNQ           : 'vpandnq';
VPANDQ            : 'vpandq';
VPAVGB            : 'vpavgb';
VPAVGW            : 'vpavgw';
VPBLENDD          : 'vpblendd';
VPBLENDMB         : 'vpblendmb';
VPBLENDMD         : 'vpblendmd';
VPBLENDMQ         : 'vpblendmq';
VPBLENDMW         : 'vpblendmw';
VPBLENDVB         : 'vpblendvb';
VPBLENDW          : 'vpblendw';
VPBROADCASTB      : 'vpbroadcastb';
VPBROADCASTD      : 'vpbroadcastd';
VPBROADCASTMB2Q   : 'vpbroadcastmb2q';
VPBROADCASTMW2D   : 'vpbroadcastmw2d';
VPBROADCASTQ      : 'vpbroadcastq';
VPBROADCASTW      : 'vpbroadcastw';
VPCLMULHQHQDQ     : 'vpclmulhqhqdq';
VPCLMULHQLQDQ     : 'vpclmulhqlqdq';
VPCLMULLQHQDQ     : 'vpclmullqhqdq';
VPCLMULLQLQDQ     : 'vpclmullqlqdq';
VPCLMULQDQ        : 'vpclmulqdq';
VPCMOV            : 'vpcmov';
VPCMPB            : 'vpcmpb';
VPCMPD            : 'vpcmpd';
VPCMPEQB          : 'vpcmpeqb';
VPCMPEQD          : 'vpcmpeqd';
VPCMPEQQ          : 'vpcmpeqq';
VPCMPEQUB         : 'vpcmpequb';
VPCMPEQUD         : 'vpcmpequd';
VPCMPEQUQ         : 'vpcmpequq';
VPCMPEQUW         : 'vpcmpequw';
VPCMPEQW          : 'vpcmpeqw';
VPCMPESTRI        : 'vpcmpestri';
VPCMPESTRM        : 'vpcmpestrm';
VPCMPGEB          : 'vpcmpgeb';
VPCMPGED          : 'vpcmpged';
VPCMPGEQ          : 'vpcmpgeq';
VPCMPGEUB         : 'vpcmpgeub';
VPCMPGEUD         : 'vpcmpgeud';
VPCMPGEUQ         : 'vpcmpgeuq';
VPCMPGEUW         : 'vpcmpgeuw';
VPCMPGEW          : 'vpcmpgew';
VPCMPGTB          : 'vpcmpgtb';
VPCMPGTD          : 'vpcmpgtd';
VPCMPGTQ          : 'vpcmpgtq';
VPCMPGTUB         : 'vpcmpgtub';
VPCMPGTUD         : 'vpcmpgtud';
VPCMPGTUQ         : 'vpcmpgtuq';
VPCMPGTUW         : 'vpcmpgtuw';
VPCMPGTW          : 'vpcmpgtw';
VPCMPISTRI        : 'vpcmpistri';
VPCMPISTRM        : 'vpcmpistrm';
VPCMPLEB          : 'vpcmpleb';
VPCMPLED          : 'vpcmpled';
VPCMPLEQ          : 'vpcmpleq';
VPCMPLEUB         : 'vpcmpleub';
VPCMPLEUD         : 'vpcmpleud';
VPCMPLEUQ         : 'vpcmpleuq';
VPCMPLEUW         : 'vpcmpleuw';
VPCMPLEW          : 'vpcmplew';
VPCMPLTB          : 'vpcmpltb';
VPCMPLTD          : 'vpcmpltd';
VPCMPLTQ          : 'vpcmpltq';
VPCMPLTUB         : 'vpcmpltub';
VPCMPLTUD         : 'vpcmpltud';
VPCMPLTUQ         : 'vpcmpltuq';
VPCMPLTUW         : 'vpcmpltuw';
VPCMPLTW          : 'vpcmpltw';
VPCMPNEQB         : 'vpcmpneqb';
VPCMPNEQD         : 'vpcmpneqd';
VPCMPNEQQ         : 'vpcmpneqq';
VPCMPNEQUB        : 'vpcmpnequb';
VPCMPNEQUD        : 'vpcmpnequd';
VPCMPNEQUQ        : 'vpcmpnequq';
VPCMPNEQUW        : 'vpcmpnequw';
VPCMPNEQW         : 'vpcmpneqw';
VPCMPNGTB         : 'vpcmpngtb';
VPCMPNGTD         : 'vpcmpngtd';
VPCMPNGTQ         : 'vpcmpngtq';
VPCMPNGTUB        : 'vpcmpngtub';
VPCMPNGTUD        : 'vpcmpngtud';
VPCMPNGTUQ        : 'vpcmpngtuq';
VPCMPNGTUW        : 'vpcmpngtuw';
VPCMPNGTW         : 'vpcmpngtw';
VPCMPNLEB         : 'vpcmpnleb';
VPCMPNLED         : 'vpcmpnled';
VPCMPNLEQ         : 'vpcmpnleq';
VPCMPNLEUB        : 'vpcmpnleub';
VPCMPNLEUD        : 'vpcmpnleud';
VPCMPNLEUQ        : 'vpcmpnleuq';
VPCMPNLEUW        : 'vpcmpnleuw';
VPCMPNLEW         : 'vpcmpnlew';
VPCMPNLTB         : 'vpcmpnltb';
VPCMPNLTD         : 'vpcmpnltd';
VPCMPNLTQ         : 'vpcmpnltq';
VPCMPNLTUB        : 'vpcmpnltub';
VPCMPNLTUD        : 'vpcmpnltud';
VPCMPNLTUQ        : 'vpcmpnltuq';
VPCMPNLTUW        : 'vpcmpnltuw';
VPCMPNLTW         : 'vpcmpnltw';
VPCMPQ            : 'vpcmpq';
VPCMPUB           : 'vpcmpub';
VPCMPUD           : 'vpcmpud';
VPCMPUQ           : 'vpcmpuq';
VPCMPUW           : 'vpcmpuw';
VPCMPW            : 'vpcmpw';
VPCOMB            : 'vpcomb';
VPCOMD            : 'vpcomd';
VPCOMPRESSB       : 'vpcompressb';
VPCOMPRESSD       : 'vpcompressd';
VPCOMPRESSQ       : 'vpcompressq';
VPCOMPRESSW       : 'vpcompressw';
VPCOMQ            : 'vpcomq';
VPCOMUB           : 'vpcomub';
VPCOMUD           : 'vpcomud';
VPCOMUQ           : 'vpcomuq';
VPCOMUW           : 'vpcomuw';
VPCOMW            : 'vpcomw';
VPCONFLICTD       : 'vpconflictd';
VPCONFLICTQ       : 'vpconflictq';
VPDPBSSD          : 'vpdpbssd';
VPDPBSSDS         : 'vpdpbssds';
VPDPBSUD          : 'vpdpbsud';
VPDPBSUDS         : 'vpdpbsuds';
VPDPBUSD          : 'vpdpbusd';
VPDPBUSDS         : 'vpdpbusds';
VPDPBUUD          : 'vpdpbuud';
VPDPBUUDS         : 'vpdpbuuds';
VPDPWSSD          : 'vpdpwssd';
VPDPWSSDS         : 'vpdpwssds';
VPERM2F128        : 'vperm2f128';
VPERM2I128        : 'vperm2i128';
VPERMB            : 'vpermb';
VPERMD            : 'vpermd';
VPERMI2B          : 'vpermi2b';
VPERMI2D          : 'vpermi2d';
VPERMI2PD         : 'vpermi2pd';
VPERMI2PS         : 'vpermi2ps';
VPERMI2Q          : 'vpermi2q';
VPERMI2W          : 'vpermi2w';
VPERMILPD         : 'vpermilpd';
VPERMILPS         : 'vpermilps';
VPERMPD           : 'vpermpd';
VPERMPS           : 'vpermps';
VPERMQ            : 'vpermq';
VPERMT2B          : 'vpermt2b';
VPERMT2D          : 'vpermt2d';
VPERMT2PD         : 'vpermt2pd';
VPERMT2PS         : 'vpermt2ps';
VPERMT2Q          : 'vpermt2q';
VPERMT2W          : 'vpermt2w';
VPERMW            : 'vpermw';
VPEXPANDB         : 'vpexpandb';
VPEXPANDD         : 'vpexpandd';
VPEXPANDQ         : 'vpexpandq';
VPEXPANDW         : 'vpexpandw';
VPEXTRB           : 'vpextrb';
VPEXTRD           : 'vpextrd';
VPEXTRQ           : 'vpextrq';
VPEXTRW           : 'vpextrw';
VPGATHERDD        : 'vpgatherdd';
VPGATHERDQ        : 'vpgatherdq';
VPGATHERQD        : 'vpgatherqd';
VPGATHERQQ        : 'vpgatherqq';
VPHADDBD          : 'vphaddbd';
VPHADDBQ          : 'vphaddbq';
VPHADDBW          : 'vphaddbw';
VPHADDD           : 'vphaddd';
VPHADDDQ          : 'vphadddq';
VPHADDSW          : 'vphaddsw';
VPHADDUBD         : 'vphaddubd';
VPHADDUBQ         : 'vphaddubq';
VPHADDUBW         : 'vphaddubw';
VPHADDUDQ         : 'vphaddudq';
VPHADDUWD         : 'vphadduwd';
VPHADDUWQ         : 'vphadduwq';
VPHADDW           : 'vphaddw';
VPHADDWD          : 'vphaddwd';
VPHADDWQ          : 'vphaddwq';
VPHMINPOSUW       : 'vphminposuw';
VPHSUBBW          : 'vphsubbw';
VPHSUBD           : 'vphsubd';
VPHSUBDQ          : 'vphsubdq';
VPHSUBSW          : 'vphsubsw';
VPHSUBW           : 'vphsubw';
VPHSUBWD          : 'vphsubwd';
VPINSRB           : 'vpinsrb';
VPINSRD           : 'vpinsrd';
VPINSRQ           : 'vpinsrq';
VPINSRW           : 'vpinsrw';
VPLZCNTD          : 'vplzcntd';
VPLZCNTQ          : 'vplzcntq';
VPMACSDD          : 'vpmacsdd';
VPMACSDQH         : 'vpmacsdqh';
VPMACSDQL         : 'vpmacsdql';
VPMACSSDD         : 'vpmacssdd';
VPMACSSDQH        : 'vpmacssdqh';
VPMACSSDQL        : 'vpmacssdql';
VPMACSSWD         : 'vpmacsswd';
VPMACSSWW         : 'vpmacssww';
VPMACSWD          : 'vpmacswd';
VPMACSWW          : 'vpmacsww';
VPMADCSSWD        : 'vpmadcsswd';
VPMADCSWD         : 'vpmadcswd';
VPMADD132PH       : 'vpmadd132ph';
VPMADD132SH       : 'vpmadd132sh';
VPMADD213PH       : 'vpmadd213ph';
VPMADD213SH       : 'vpmadd213sh';
VPMADD231PH       : 'vpmadd231ph';
VPMADD231SH       : 'vpmadd231sh';
VPMADD52HUQ       : 'vpmadd52huq';
VPMADD52LUQ       : 'vpmadd52luq';
VPMADDUBSW        : 'vpmaddubsw';
VPMADDWD          : 'vpmaddwd';
VPMASKMOVD        : 'vpmaskmovd';
VPMASKMOVQ        : 'vpmaskmovq';
VPMAXSB           : 'vpmaxsb';
VPMAXSD           : 'vpmaxsd';
VPMAXSQ           : 'vpmaxsq';
VPMAXSW           : 'vpmaxsw';
VPMAXUB           : 'vpmaxub';
VPMAXUD           : 'vpmaxud';
VPMAXUQ           : 'vpmaxuq';
VPMAXUW           : 'vpmaxuw';
VPMINSB           : 'vpminsb';
VPMINSD           : 'vpminsd';
VPMINSQ           : 'vpminsq';
VPMINSW           : 'vpminsw';
VPMINUB           : 'vpminub';
VPMINUD           : 'vpminud';
VPMINUQ           : 'vpminuq';
VPMINUW           : 'vpminuw';
VPMOVB2M          : 'vpmovb2m';
VPMOVD2M          : 'vpmovd2m';
VPMOVDB           : 'vpmovdb';
VPMOVDW           : 'vpmovdw';
VPMOVM2B          : 'vpmovm2b';
VPMOVM2D          : 'vpmovm2d';
VPMOVM2Q          : 'vpmovm2q';
VPMOVM2W          : 'vpmovm2w';
VPMOVMSKB         : 'vpmovmskb';
VPMOVQ2M          : 'vpmovq2m';
VPMOVQB           : 'vpmovqb';
VPMOVQD           : 'vpmovqd';
VPMOVQW           : 'vpmovqw';
VPMOVSDB          : 'vpmovsdb';
VPMOVSDW          : 'vpmovsdw';
VPMOVSQB          : 'vpmovsqb';
VPMOVSQD          : 'vpmovsqd';
VPMOVSQW          : 'vpmovsqw';
VPMOVSWB          : 'vpmovswb';
VPMOVSXBD         : 'vpmovsxbd';
VPMOVSXBQ         : 'vpmovsxbq';
VPMOVSXBW         : 'vpmovsxbw';
VPMOVSXDQ         : 'vpmovsxdq';
VPMOVSXWD         : 'vpmovsxwd';
VPMOVSXWQ         : 'vpmovsxwq';
VPMOVUSDB         : 'vpmovusdb';
VPMOVUSDW         : 'vpmovusdw';
VPMOVUSQB         : 'vpmovusqb';
VPMOVUSQD         : 'vpmovusqd';
VPMOVUSQW         : 'vpmovusqw';
VPMOVUSWB         : 'vpmovuswb';
VPMOVW2M          : 'vpmovw2m';
VPMOVWB           : 'vpmovwb';
VPMOVZXBD         : 'vpmovzxbd';
VPMOVZXBQ         : 'vpmovzxbq';
VPMOVZXBW         : 'vpmovzxbw';
VPMOVZXDQ         : 'vpmovzxdq';
VPMOVZXWD         : 'vpmovzxwd';
VPMOVZXWQ         : 'vpmovzxwq';
VPMSUB132PH       : 'vpmsub132ph';
VPMSUB132SH       : 'vpmsub132sh';
VPMSUB213PH       : 'vpmsub213ph';
VPMSUB213SH       : 'vpmsub213sh';
VPMSUB231PH       : 'vpmsub231ph';
VPMSUB231SH       : 'vpmsub231sh';
VPMULDQ           : 'vpmuldq';
VPMULHRSW         : 'vpmulhrsw';
VPMULHUW          : 'vpmulhuw';
VPMULHW           : 'vpmulhw';
VPMULLD           : 'vpmulld';
VPMULLQ           : 'vpmullq';
VPMULLW           : 'vpmullw';
VPMULTISHIFTQB    : 'vpmultishiftqb';
VPMULUDQ          : 'vpmuludq';
VPNMADD132SH      : 'vpnmadd132sh';
VPNMADD213SH      : 'vpnmadd213sh';
VPNMADD231SH      : 'vpnmadd231sh';
VPNMSUB132SH      : 'vpnmsub132sh';
VPNMSUB213SH      : 'vpnmsub213sh';
VPNMSUB231SH      : 'vpnmsub231sh';
VPOPCNTB          : 'vpopcntb';
VPOPCNTD          : 'vpopcntd';
VPOPCNTQ          : 'vpopcntq';
VPOPCNTW          : 'vpopcntw';
VPOR              : 'vpor';
VPORD             : 'vpord';
VPORQ             : 'vporq';
VPPERM            : 'vpperm';
VPROLD            : 'vprold';
VPROLQ            : 'vprolq';
VPROLVD           : 'vprolvd';
VPROLVQ           : 'vprolvq';
VPRORD            : 'vprord';
VPRORQ            : 'vprorq';
VPRORVD           : 'vprorvd';
VPRORVQ           : 'vprorvq';
VPROTB            : 'vprotb';
VPROTD            : 'vprotd';
VPROTQ            : 'vprotq';
VPROTW            : 'vprotw';
VPSADBW           : 'vpsadbw';
VPSCATTERDD       : 'vpscatterdd';
VPSCATTERDQ       : 'vpscatterdq';
VPSCATTERQD       : 'vpscatterqd';
VPSCATTERQQ       : 'vpscatterqq';
VPSHAB            : 'vpshab';
VPSHAD            : 'vpshad';
VPSHAQ            : 'vpshaq';
VPSHAW            : 'vpshaw';
VPSHLB            : 'vpshlb';
VPSHLD            : 'vpshld';
VPSHLDD           : 'vpshldd';
VPSHLDQ           : 'vpshldq';
VPSHLDVD          : 'vpshldvd';
VPSHLDVQ          : 'vpshldvq';
VPSHLDVW          : 'vpshldvw';
VPSHLDW           : 'vpshldw';
VPSHLQ            : 'vpshlq';
VPSHLW            : 'vpshlw';
VPSHRDD           : 'vpshrdd';
VPSHRDQ           : 'vpshrdq';
VPSHRDVD          : 'vpshrdvd';
VPSHRDVQ          : 'vpshrdvq';
VPSHRDVW          : 'vpshrdvw';
VPSHRDW           : 'vpshrdw';
VPSHUFB           : 'vpshufb';
VPSHUFBITQMB      : 'vpshufbitqmb';
VPSHUFD           : 'vpshufd';
VPSHUFHW          : 'vpshufhw';
VPSHUFLW          : 'vpshuflw';
VPSIGNB           : 'vpsignb';
VPSIGND           : 'vpsignd';
VPSIGNW           : 'vpsignw';
VPSLLD            : 'vpslld';
VPSLLDQ           : 'vpslldq';
VPSLLQ            : 'vpsllq';
VPSLLVD           : 'vpsllvd';
VPSLLVQ           : 'vpsllvq';
VPSLLVW           : 'vpsllvw';
VPSLLW            : 'vpsllw';
VPSRAD            : 'vpsrad';
VPSRAQ            : 'vpsraq';
VPSRAVD           : 'vpsravd';
VPSRAVQ           : 'vpsravq';
VPSRAVW           : 'vpsravw';
VPSRAW            : 'vpsraw';
VPSRLD            : 'vpsrld';
VPSRLDQ           : 'vpsrldq';
VPSRLQ            : 'vpsrlq';
VPSRLVD           : 'vpsrlvd';
VPSRLVQ           : 'vpsrlvq';
VPSRLVW           : 'vpsrlvw';
VPSRLW            : 'vpsrlw';
VPSUBB            : 'vpsubb';
VPSUBD            : 'vpsubd';
VPSUBQ            : 'vpsubq';
VPSUBSB           : 'vpsubsb';
VPSUBSW           : 'vpsubsw';
VPSUBUSB          : 'vpsubusb';
VPSUBUSW          : 'vpsubusw';
VPSUBW            : 'vpsubw';
VPTERNLOGD        : 'vpternlogd';
VPTERNLOGQ        : 'vpternlogq';
VPTEST            : 'vptest';
VPTESTMB          : 'vptestmb';
VPTESTMD          : 'vptestmd';
VPTESTMQ          : 'vptestmq';
VPTESTMW          : 'vptestmw';
VPTESTNMB         : 'vptestnmb';
VPTESTNMD         : 'vptestnmd';
VPTESTNMQ         : 'vptestnmq';
VPTESTNMW         : 'vptestnmw';
VPUNPCKHBW        : 'vpunpckhbw';
VPUNPCKHDQ        : 'vpunpckhdq';
VPUNPCKHQDQ       : 'vpunpckhqdq';
VPUNPCKHWD        : 'vpunpckhwd';
VPUNPCKLBW        : 'vpunpcklbw';
VPUNPCKLDQ        : 'vpunpckldq';
VPUNPCKLQDQ       : 'vpunpcklqdq';
VPUNPCKLWD        : 'vpunpcklwd';
VPXOR             : 'vpxor';
VPXORD            : 'vpxord';
VPXORQ            : 'vpxorq';
VRANGEPD          : 'vrangepd';
VRANGEPS          : 'vrangeps';
VRANGESD          : 'vrangesd';
VRANGESS          : 'vrangess';
VRCP14PD          : 'vrcp14pd';
VRCP14PS          : 'vrcp14ps';
VRCP14SD          : 'vrcp14sd';
VRCP14SS          : 'vrcp14ss';
VRCP28PD          : 'vrcp28pd';
VRCP28PS          : 'vrcp28ps';
VRCP28SD          : 'vrcp28sd';
VRCP28SS          : 'vrcp28ss';
VRCPPH            : 'vrcpph';
VRCPPS            : 'vrcpps';
VRCPSH            : 'vrcpsh';
VRCPSS            : 'vrcpss';
VREDUCEPD         : 'vreducepd';
VREDUCEPH         : 'vreduceph';
VREDUCEPS         : 'vreduceps';
VREDUCESD         : 'vreducesd';
VREDUCESH         : 'vreducesh';
VREDUCESS         : 'vreducess';
VRNDSCALEPD       : 'vrndscalepd';
VRNDSCALEPS       : 'vrndscaleps';
VRNDSCALESD       : 'vrndscalesd';
VRNDSCALESS       : 'vrndscaless';
VROUNDPD          : 'vroundpd';
VROUNDPS          : 'vroundps';
VROUNDSD          : 'vroundsd';
VROUNDSS          : 'vroundss';
VRSQRT14PD        : 'vrsqrt14pd';
VRSQRT14PS        : 'vrsqrt14ps';
VRSQRT14SD        : 'vrsqrt14sd';
VRSQRT14SS        : 'vrsqrt14ss';
VRSQRT28PD        : 'vrsqrt28pd';
VRSQRT28PS        : 'vrsqrt28ps';
VRSQRT28SD        : 'vrsqrt28sd';
VRSQRT28SS        : 'vrsqrt28ss';
VRSQRTPH          : 'vrsqrtph';
VRSQRTPS          : 'vrsqrtps';
VRSQRTSH          : 'vrsqrtsh';
VRSQRTSS          : 'vrsqrtss';
VSCALEFPD         : 'vscalefpd';
VSCALEFPH         : 'vscalefph';
VSCALEFPS         : 'vscalefps';
VSCALEFSD         : 'vscalefsd';
VSCALEFSH         : 'vscalefsh';
VSCALEFSS         : 'vscalefss';
VSCATTERDPD       : 'vscatterdpd';
VSCATTERDPS       : 'vscatterdps';
VSCATTERPF0DPD    : 'vscatterpf0dpd';
VSCATTERPF0DPS    : 'vscatterpf0dps';
VSCATTERPF0QPD    : 'vscatterpf0qpd';
VSCATTERPF0QPS    : 'vscatterpf0qps';
VSCATTERPF1DPD    : 'vscatterpf1dpd';
VSCATTERPF1DPS    : 'vscatterpf1dps';
VSCATTERPF1QPD    : 'vscatterpf1qpd';
VSCATTERPF1QPS    : 'vscatterpf1qps';
VSCATTERQPD       : 'vscatterqpd';
VSCATTERQPS       : 'vscatterqps';
VSHUFF32X4        : 'vshuff32x4';
VSHUFF64X2        : 'vshuff64x2';
VSHUFI32X4        : 'vshufi32x4';
VSHUFI64X2        : 'vshufi64x2';
VSHUFPD           : 'vshufpd';
VSHUFPS           : 'vshufps';
VSQRTPD           : 'vsqrtpd';
VSQRTPH           : 'vsqrtph';
VSQRTPS           : 'vsqrtps';
VSQRTSD           : 'vsqrtsd';
VSQRTSH           : 'vsqrtsh';
VSQRTSS           : 'vsqrtss';
VSTMXCSR          : 'vstmxcsr';
VSUBPD            : 'vsubpd';
VSUBPH            : 'vsubph';
VSUBPS            : 'vsubps';
VSUBSD            : 'vsubsd';
VSUBSH            : 'vsubsh';
VSUBSS            : 'vsubss';
VTESTPD           : 'vtestpd';
VTESTPS           : 'vtestps';
VUCOMISD          : 'vucomisd';
VUCOMISH          : 'vucomish';
VUCOMISS          : 'vucomiss';
VUNPCKHPD         : 'vunpckhpd';
VUNPCKHPS         : 'vunpckhps';
VUNPCKLPD         : 'vunpcklpd';
VUNPCKLPS         : 'vunpcklps';
VXORPD            : 'vxorpd';
VXORPS            : 'vxorps';
VZEROALL          : 'vzeroall';
VZEROUPPER        : 'vzeroupper';
WBNOINVD          : 'wbnoinvd';
WRFSBASE          : 'wrfsbase';
WRGSBASE          : 'wrgsbase';
WRMSRLIST         : 'wrmsrlist';
WRMSRNS           : 'wrmsrns';
WRPKRU            : 'wrpkru';
WRSSD             : 'wrssd';
WRSSQ             : 'wrssq';
WRUSSD            : 'wrussd';
WRUSSQ            : 'wrussq';
XABORT            : 'xabort';
XBEGIN            : 'xbegin';
XCRYPTCBC         : 'xcryptcbc';
XCRYPTCFB         : 'xcryptcfb';
XCRYPTCTR         : 'xcryptctr';
XCRYPTECB         : 'xcryptecb';
XCRYPTOFB         : 'xcryptofb';
XEND              : 'xend';
XGETBV            : 'xgetbv';
XORPD             : 'xorpd';
XORPS             : 'xorps';
XRESLDTRK         : 'xresldtrk';
XRSTOR            : 'xrstor';
XRSTOR64          : 'xrstor64';
XRSTORS           : 'xrstors';
XRSTORS64         : 'xrstors64';
XSAVE             : 'xsave';
XSAVE64           : 'xsave64';
XSAVEC            : 'xsavec';
XSAVEC64          : 'xsavec64';
XSAVEOPT          : 'xsaveopt';
XSAVEOPT64        : 'xsaveopt64';
XSAVES            : 'xsaves';
XSAVES64          : 'xsaves64';
XSETBV            : 'xsetbv';
XSHA1             : 'xsha1';
XSHA256           : 'xsha256';
XSTORE            : 'xstore';
XSUSLDTRK         : 'xsusldtrk';
XTEST             : 'xtest';

BITS              : 'bits';
USE16             : 'use16';
USE32             : 'use32';
DEFAULT           : 'default';
REL               : 'rel';
ABS               : 'abs';
BND               : 'bnd';
NOBND             : 'nobnd';
SECTIONS          : 'sections';
SECTION           : 'section';
SEGMENTS          : 'segments';
SEGMENT           : 'segment';
ABSOLUTE          : 'absolute';
EXTERN            : 'extern';
REQUIRED          : 'required';
GLOBAL            : 'global';
COMMON            : 'common';
NEAR              : 'near';
FAR               : 'far';
STATIC            : 'static';
CPU               : 'cpu';
FLOAT_NAME        : 'float';
DAZ               : 'daz';
NODAZ             : 'nodaz';
UP                : 'up';
DOWN              : 'down';
ZERO              : 'zero';
WARNING           : 'warning';
ORG               : 'org';
ALIGN             : 'align';
VSTART            : 'vstart';
START             : 'start';
PROGBITS          : 'progbits';
NOBITS            : 'nobits';
VFOLLOWS          : 'vfollows';
FOLLOWS           : 'follows';
MAP               : 'map';
ALL               : 'all';
BRIEF             : 'brief';
SYMBOLS           : 'symbols';
PRIVATE           : 'private';
PUBLIC            : 'public';
STACK             : 'stack';
CLASS_            : 'class';
OVERLAY           : 'overlay';
FLAT              : 'flat';
GROUP             : 'group';
UPPERCASE         : 'uppercase';
IMPORT            : 'import';
EXPORT            : 'export';
RESIDENT          : 'resident';
NODATA            : 'nodata';
PARM              : 'parm';
CODE              : 'code';
TEXT              : 'text';
RDATA             : 'rdata';
DATA              : 'data';
BSS               : 'bss';
INFO              : 'info';
COMDAT            : 'comdat';
SAFESEH           : 'safeseh';
MIXED             : 'mixed';
ZEROFILL          : 'zerofill';
NO_DEAD_STRIP     : 'no_dead_strip';
LIVE_SUPPORT      : 'live_support';
STRIP_STATIC_SYMS : 'strip_static_syms';
DEBUG             : 'debug';
OSABI             : 'osabi';
NOTE              : 'note';
PREINIT_ARRAY     : 'preinit_array';
INIT_ARRAY        : 'init_array';
FINI_ARRAY        : 'fini_array';
TLS               : 'tls';
POINTER           : 'pointer';
NOALLOC           : 'noalloc';
ALLOC             : 'alloc';
NOEXEC            : 'noexec';
EXEC              : 'exec';
NOWRITE           : 'nowrite';
WRITE             : 'write';
WRT               : 'wrt';
FUNCTION          : 'function';
OBJECT            : 'object';
WEAK              : 'weak';
STRONG            : 'strong';
INTERNAL          : 'internal';
HIDDEN_           : 'hidden';
PROTECTED         : 'protected';
STRICT            : 'strict';
TIMES             : 'times';

FLOAT_NUMBER: [0-9][0-9_]* '.' [0-9_]* 'e'? SIGN? [0-9_]+ | '0x1p+' [0-9]+;

DECIMAL_INTEGER: [0-9][0-9_]* 'd'? | '0d' [0-9][0-9_]*;

SIGN: PLUS | MINUS;

OCT_INTEGER: [0-7][0-7_]* ('q' | 'o') | '0' [qo][0-7][0-7_]*;

HEX_INTEGER: [0-9A-F][0-9A-F_]+ 'h' | '$' [0-9A-F][0-9A-F_]* | '0' [xh][0-9A-F][0-9A-F_]*;

BIN_INTEGER: [01][01_]+ ('b' | 'y') | '0' [by][01][01_]*;

STRING: STRING1 | STRING2;

STRING1: '"' ~'"'* '"';

STRING2: '\u0027' ~'\u0027'* '\u0027';

WARNING_NAME: NAME (MINUS NAME)+;

NAME: [a-z._?][a-z0-9_$#@~.?]*;

PREPROCESSOR_DIRECTIVES:
    '%' (
        'define'
        | 'xdefine'
        | 'ixdefine'
        | 'undef'
        | 'assign'
        | 'iassign'
        | 'defstr'
        | 'deftok'
        | 'defalias'
        | 'undefalias'
        | 'strcat'
        | 'strlen'
        | 'substr'
        | 'include'
        | 'pathsearch'
        | 'depend'
        | 'use'
        | 'line'
        | 'clear'
    ) ~[\r\n]* -> channel(HIDDEN)
;

MULTILINE_MACRO: '%macro' .*? '%endmacro' -> channel(HIDDEN);

COMMENT: ';' ~[\r\n]* -> channel(HIDDEN);

EOL: [\r\n]+;

WHITESPACE: [ \t] -> channel(HIDDEN);